[llvm] c5e1ddb - [ConstraintElimination] Update tests to use opaque pointers.
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Thu Oct 6 10:07:52 PDT 2022
Author: Florian Hahn
Date: 2022-10-06T18:07:25+01:00
New Revision: c5e1ddb6fddef6f0d0ffc9acc9b0a2f3534b303f
URL: https://github.com/llvm/llvm-project/commit/c5e1ddb6fddef6f0d0ffc9acc9b0a2f3534b303f
DIFF: https://github.com/llvm/llvm-project/commit/c5e1ddb6fddef6f0d0ffc9acc9b0a2f3534b303f.diff
LOG: [ConstraintElimination] Update tests to use opaque pointers.
Added:
Modified:
llvm/test/Transforms/ConstraintElimination/and.ll
llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll
llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll
llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll
llvm/test/Transforms/ConstraintElimination/geps-signed-predicates.ll
llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll
llvm/test/Transforms/ConstraintElimination/invoke.ll
llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll
llvm/test/Transforms/ConstraintElimination/large-system-growth.ll
llvm/test/Transforms/ConstraintElimination/loops-bottom-tested-pointer-cmps.ll
llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll
llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll
llvm/test/Transforms/ConstraintElimination/ugt-ule.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/ConstraintElimination/and.ll b/llvm/test/Transforms/ConstraintElimination/and.ll
index 25fab8de49a9d..594c3b6dc0dff 100644
--- a/llvm/test/Transforms/ConstraintElimination/and.ll
+++ b/llvm/test/Transforms/ConstraintElimination/and.ll
@@ -148,15 +148,15 @@ exit:
ret i4 3
}
-define i1 @test_and_condition_trivially_false(i1 %c, i8* %ptr.1, i8 %idx, i8* %ptr.2) {
+define i1 @test_and_condition_trivially_false(i1 %c, ptr %ptr.1, i8 %idx, ptr %ptr.2) {
; CHECK-LABEL: @test_and_condition_trivially_false(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[THEN:%.*]], label [[EXIT_3:%.*]]
; CHECK: then:
-; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i8* [[PTR_2:%.*]], [[PTR_2]]
+; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt ptr [[PTR_2:%.*]], [[PTR_2]]
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i8 [[IDX:%.*]] to i16
-; CHECK-NEXT: [[GEP_IDX_EXT:%.*]] = getelementptr inbounds i8, i8* [[PTR_1:%.*]], i16 [[IDX_EXT]]
-; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult i8* [[PTR_2]], [[GEP_IDX_EXT]]
+; CHECK-NEXT: [[GEP_IDX_EXT:%.*]] = getelementptr inbounds i8, ptr [[PTR_1:%.*]], i16 [[IDX_EXT]]
+; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult ptr [[PTR_2]], [[GEP_IDX_EXT]]
; CHECK-NEXT: [[AND:%.*]] = and i1 false, [[CMP_2]]
; CHECK-NEXT: br i1 [[AND]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
; CHECK: exit.1:
@@ -171,18 +171,18 @@ entry:
br i1 %c, label %then, label %exit.3
then:
- %cmp.1 = icmp ugt i8* %ptr.2, %ptr.2
+ %cmp.1 = icmp ugt ptr %ptr.2, %ptr.2
%idx.ext = zext i8 %idx to i16
- %gep.idx.ext = getelementptr inbounds i8, i8* %ptr.1, i16 %idx.ext
- %cmp.2 = icmp ult i8* %ptr.2, %gep.idx.ext
+ %gep.idx.ext = getelementptr inbounds i8, ptr %ptr.1, i16 %idx.ext
+ %cmp.2 = icmp ult ptr %ptr.2, %gep.idx.ext
%and = and i1 %cmp.1, %cmp.2
br i1 %and, label %exit.1, label %exit.2
exit.1:
- ret i1 1
+ ret i1 true
exit.2:
- ret i1 0
+ ret i1 false
exit.3:
%cmp.3 = icmp ne i8 %idx, 0
diff --git a/llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll b/llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll
index 7a90d5988a356..f2a433a17bb05 100644
--- a/llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll
+++ b/llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll
@@ -1,179 +1,167 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
-declare void @llvm.assume(i1)
+declare void @llvm.assume(i1 noundef) #0
-define i1 @gep_constant_positive_index(i8* %dst, i8* %lower, i8* %upper) {
+define i1 @gep_constant_positive_index(ptr %dst, ptr %lower, ptr %upper) {
; CHECK-LABEL: @gep_constant_positive_index(
-; CHECK-NEXT: [[DST_ADD_4:%.*]] = getelementptr inbounds i8, i8* [[DST:%.*]], i64 4
-; CHECK-NEXT: [[PRE_DST_LOWER:%.*]] = icmp uge i8* [[DST]], [[LOWER:%.*]]
-; CHECK-NEXT: [[PRE_DST_UPPER:%.*]] = icmp ult i8* [[DST_ADD_4]], [[UPPER:%.*]]
+; CHECK-NEXT: [[DST_ADD_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 4
+; CHECK-NEXT: [[PRE_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER:%.*]]
+; CHECK-NEXT: [[PRE_DST_UPPER:%.*]] = icmp ult ptr [[DST_ADD_4]], [[UPPER:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[PRE_DST_LOWER]], [[PRE_DST_UPPER]]
; CHECK-NEXT: br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
-; CHECK-NEXT: [[CMP_DST_LOWER:%.*]] = icmp uge i8* [[DST]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_UPPER:%.*]] = icmp ult i8* [[DST]], [[UPPER]]
+; CHECK-NEXT: [[CMP_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_UPPER:%.*]] = icmp ult ptr [[DST]], [[UPPER]]
; CHECK-NEXT: [[RES_1:%.*]] = xor i1 true, true
-; CHECK-NEXT: [[DST_ADD_3:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 3
-; CHECK-NEXT: [[CMP_DST_ADD_3_LOWER:%.*]] = icmp uge i8* [[DST_ADD_3]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_ADD_3_UPPER:%.*]] = icmp ult i8* [[DST_ADD_3]], [[UPPER]]
+; CHECK-NEXT: [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
+; CHECK-NEXT: [[CMP_DST_ADD_3_LOWER:%.*]] = icmp uge ptr [[DST_ADD_3]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_ADD_3_UPPER:%.*]] = icmp ult ptr [[DST_ADD_3]], [[UPPER]]
; CHECK-NEXT: [[RES_2:%.*]] = xor i1 [[RES_1]], true
; CHECK-NEXT: [[RES_3:%.*]] = xor i1 [[RES_2]], true
-; CHECK-NEXT: [[CMP_DST_ADD_4_LOWER:%.*]] = icmp uge i8* [[DST_ADD_4]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_ADD_4_UPPER:%.*]] = icmp ult i8* [[DST_ADD_4]], [[UPPER]]
+; CHECK-NEXT: [[CMP_DST_ADD_4_LOWER:%.*]] = icmp uge ptr [[DST_ADD_4]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_ADD_4_UPPER:%.*]] = icmp ult ptr [[DST_ADD_4]], [[UPPER]]
; CHECK-NEXT: [[RES_4:%.*]] = xor i1 [[RES_3]], true
; CHECK-NEXT: [[RES_5:%.*]] = xor i1 [[RES_4]], true
-; CHECK-NEXT: [[DST_ADD_5:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 5
-; CHECK-NEXT: [[CMP_DST_ADD_5_LOWER:%.*]] = icmp uge i8* [[DST_ADD_5]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_ADD_5_UPPER:%.*]] = icmp ult i8* [[DST_ADD_5]], [[UPPER]]
+; CHECK-NEXT: [[DST_ADD_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
+; CHECK-NEXT: [[CMP_DST_ADD_5_LOWER:%.*]] = icmp uge ptr [[DST_ADD_5]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_ADD_5_UPPER:%.*]] = icmp ult ptr [[DST_ADD_5]], [[UPPER]]
; CHECK-NEXT: [[RES_6:%.*]] = xor i1 [[RES_5]], true
; CHECK-NEXT: [[RES_7:%.*]] = xor i1 [[RES_6]], [[CMP_DST_ADD_5_UPPER]]
; CHECK-NEXT: ret i1 [[RES_7]]
; CHECK: else:
; CHECK-NEXT: ret i1 false
;
- %dst.add.4 = getelementptr inbounds i8, i8* %dst, i64 4
- %pre.dst.lower = icmp uge i8* %dst, %lower
- %pre.dst.upper = icmp ult i8* %dst.add.4, %upper
+ %dst.add.4 = getelementptr inbounds i8, ptr %dst, i64 4
+ %pre.dst.lower = icmp uge ptr %dst, %lower
+ %pre.dst.upper = icmp ult ptr %dst.add.4, %upper
%and = and i1 %pre.dst.lower, %pre.dst.upper
br i1 %and, label %then, label %else
then:
- %cmp.dst.lower = icmp uge i8* %dst, %lower
- %cmp.dst.upper = icmp ult i8* %dst, %upper
+ %cmp.dst.lower = icmp uge ptr %dst, %lower
+ %cmp.dst.upper = icmp ult ptr %dst, %upper
%res.1 = xor i1 %cmp.dst.lower, %cmp.dst.upper
-
- %dst.add.3 = getelementptr inbounds i8, i8* %dst, i64 3
- %cmp.dst.add.3.lower = icmp uge i8* %dst.add.3, %lower
- %cmp.dst.add.3.upper = icmp ult i8* %dst.add.3, %upper
+ %dst.add.3 = getelementptr inbounds i8, ptr %dst, i64 3
+ %cmp.dst.add.3.lower = icmp uge ptr %dst.add.3, %lower
+ %cmp.dst.add.3.upper = icmp ult ptr %dst.add.3, %upper
%res.2 = xor i1 %res.1, %cmp.dst.add.3.lower
%res.3 = xor i1 %res.2, %cmp.dst.add.3.upper
-
- %cmp.dst.add.4.lower = icmp uge i8* %dst.add.4, %lower
- %cmp.dst.add.4.upper = icmp ult i8* %dst.add.4, %upper
+ %cmp.dst.add.4.lower = icmp uge ptr %dst.add.4, %lower
+ %cmp.dst.add.4.upper = icmp ult ptr %dst.add.4, %upper
%res.4 = xor i1 %res.3, %cmp.dst.add.4.lower
%res.5 = xor i1 %res.4, %cmp.dst.add.4.upper
-
- %dst.add.5 = getelementptr inbounds i8, i8* %dst, i64 5
- %cmp.dst.add.5.lower = icmp uge i8* %dst.add.5, %lower
- %cmp.dst.add.5.upper = icmp ult i8* %dst.add.5, %upper
+ %dst.add.5 = getelementptr inbounds i8, ptr %dst, i64 5
+ %cmp.dst.add.5.lower = icmp uge ptr %dst.add.5, %lower
+ %cmp.dst.add.5.upper = icmp ult ptr %dst.add.5, %upper
%res.6 = xor i1 %res.5, %cmp.dst.add.5.lower
%res.7 = xor i1 %res.6, %cmp.dst.add.5.upper
-
ret i1 %res.7
else:
ret i1 false
}
-define i1 @gep_constant_negative_index(i8* %dst, i8* %lower, i8* %upper) {
+define i1 @gep_constant_negative_index(ptr %dst, ptr %lower, ptr %upper) {
; CHECK-LABEL: @gep_constant_negative_index(
-; CHECK-NEXT: [[DST_SUB_4:%.*]] = getelementptr inbounds i8, i8* [[DST:%.*]], i64 -4
-; CHECK-NEXT: [[PRE_DST_LOWER:%.*]] = icmp uge i8* [[DST]], [[LOWER:%.*]]
-; CHECK-NEXT: [[PRE_DST_UPPER:%.*]] = icmp ult i8* [[DST_SUB_4]], [[UPPER:%.*]]
+; CHECK-NEXT: [[DST_SUB_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 -4
+; CHECK-NEXT: [[PRE_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER:%.*]]
+; CHECK-NEXT: [[PRE_DST_UPPER:%.*]] = icmp ult ptr [[DST_SUB_4]], [[UPPER:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[PRE_DST_LOWER]], [[PRE_DST_UPPER]]
; CHECK-NEXT: br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
-; CHECK-NEXT: [[CMP_DST_LOWER:%.*]] = icmp uge i8* [[DST]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_UPPER:%.*]] = icmp ult i8* [[DST]], [[UPPER]]
+; CHECK-NEXT: [[CMP_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_UPPER:%.*]] = icmp ult ptr [[DST]], [[UPPER]]
; CHECK-NEXT: [[RES_1:%.*]] = xor i1 true, [[CMP_DST_UPPER]]
-; CHECK-NEXT: [[DST_SUB_3:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 -3
-; CHECK-NEXT: [[CMP_DST_SUB_3_LOWER:%.*]] = icmp uge i8* [[DST_SUB_3]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_SUB_3_UPPER:%.*]] = icmp ult i8* [[DST_SUB_3]], [[UPPER]]
+; CHECK-NEXT: [[DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -3
+; CHECK-NEXT: [[CMP_DST_SUB_3_LOWER:%.*]] = icmp uge ptr [[DST_SUB_3]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_SUB_3_UPPER:%.*]] = icmp ult ptr [[DST_SUB_3]], [[UPPER]]
; CHECK-NEXT: [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_DST_SUB_3_LOWER]]
; CHECK-NEXT: [[RES_3:%.*]] = xor i1 [[RES_2]], [[CMP_DST_SUB_3_UPPER]]
-; CHECK-NEXT: [[CMP_DST_SUB_4_LOWER:%.*]] = icmp uge i8* [[DST_SUB_4]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_SUB_4_UPPER:%.*]] = icmp ult i8* [[DST_SUB_4]], [[UPPER]]
+; CHECK-NEXT: [[CMP_DST_SUB_4_LOWER:%.*]] = icmp uge ptr [[DST_SUB_4]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_SUB_4_UPPER:%.*]] = icmp ult ptr [[DST_SUB_4]], [[UPPER]]
; CHECK-NEXT: [[RES_4:%.*]] = xor i1 [[RES_3]], [[CMP_DST_SUB_4_LOWER]]
; CHECK-NEXT: [[RES_5:%.*]] = xor i1 [[RES_4]], [[CMP_DST_SUB_4_UPPER]]
-; CHECK-NEXT: [[DST_SUB_5:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 -5
-; CHECK-NEXT: [[CMP_DST_SUB_5_LOWER:%.*]] = icmp uge i8* [[DST_SUB_5]], [[LOWER]]
-; CHECK-NEXT: [[CMP_DST_SUB_5_UPPER:%.*]] = icmp ult i8* [[DST_SUB_5]], [[UPPER]]
+; CHECK-NEXT: [[DST_SUB_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -5
+; CHECK-NEXT: [[CMP_DST_SUB_5_LOWER:%.*]] = icmp uge ptr [[DST_SUB_5]], [[LOWER]]
+; CHECK-NEXT: [[CMP_DST_SUB_5_UPPER:%.*]] = icmp ult ptr [[DST_SUB_5]], [[UPPER]]
; CHECK-NEXT: [[RES_6:%.*]] = xor i1 [[RES_5]], [[CMP_DST_SUB_5_LOWER]]
; CHECK-NEXT: [[RES_7:%.*]] = xor i1 [[RES_6]], [[CMP_DST_SUB_5_UPPER]]
; CHECK-NEXT: ret i1 [[RES_7]]
; CHECK: else:
-; CHECK-NEXT: [[ELSE_CMP_DST_LOWER:%.*]] = icmp uge i8* [[DST]], [[LOWER]]
-; CHECK-NEXT: [[ELSE_CMP_DST_UPPER:%.*]] = icmp ult i8* [[DST]], [[UPPER]]
+; CHECK-NEXT: [[ELSE_CMP_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER]]
+; CHECK-NEXT: [[ELSE_CMP_DST_UPPER:%.*]] = icmp ult ptr [[DST]], [[UPPER]]
; CHECK-NEXT: [[ELSE_RES_1:%.*]] = xor i1 [[ELSE_CMP_DST_LOWER]], [[ELSE_CMP_DST_UPPER]]
-; CHECK-NEXT: [[ELSE_DST_SUB_3:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 -3
-; CHECK-NEXT: [[ELSE_CMP_DST_SUB_3_LOWER:%.*]] = icmp uge i8* [[ELSE_DST_SUB_3]], [[LOWER]]
-; CHECK-NEXT: [[ELSE_CMP_DST_SUB_3_UPPER:%.*]] = icmp ult i8* [[ELSE_DST_SUB_3]], [[UPPER]]
+; CHECK-NEXT: [[ELSE_DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -3
+; CHECK-NEXT: [[ELSE_CMP_DST_SUB_3_LOWER:%.*]] = icmp uge ptr [[ELSE_DST_SUB_3]], [[LOWER]]
+; CHECK-NEXT: [[ELSE_CMP_DST_SUB_3_UPPER:%.*]] = icmp ult ptr [[ELSE_DST_SUB_3]], [[UPPER]]
; CHECK-NEXT: [[ELSE_RES_2:%.*]] = xor i1 [[ELSE_RES_1]], [[ELSE_CMP_DST_SUB_3_LOWER]]
; CHECK-NEXT: [[ELSE_RES_3:%.*]] = xor i1 [[ELSE_RES_2]], [[ELSE_CMP_DST_SUB_3_UPPER]]
-; CHECK-NEXT: [[ELSE_CMP_DST_SUB_4_LOWER:%.*]] = icmp uge i8* [[DST_SUB_4]], [[LOWER]]
-; CHECK-NEXT: [[ELSE_CMP_DST_SUB_4_UPPER:%.*]] = icmp ult i8* [[DST_SUB_4]], [[UPPER]]
+; CHECK-NEXT: [[ELSE_CMP_DST_SUB_4_LOWER:%.*]] = icmp uge ptr [[DST_SUB_4]], [[LOWER]]
+; CHECK-NEXT: [[ELSE_CMP_DST_SUB_4_UPPER:%.*]] = icmp ult ptr [[DST_SUB_4]], [[UPPER]]
; CHECK-NEXT: [[ELSE_RES_4:%.*]] = xor i1 [[ELSE_RES_3]], [[ELSE_CMP_DST_SUB_4_LOWER]]
; CHECK-NEXT: [[ELSE_RES_5:%.*]] = xor i1 [[ELSE_RES_4]], [[ELSE_CMP_DST_SUB_4_UPPER]]
-; CHECK-NEXT: [[ELSE_DST_SUB_5:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 -5
-; CHECK-NEXT: [[ELSE_CMP_DST_SUB_5_LOWER:%.*]] = icmp uge i8* [[ELSE_DST_SUB_5]], [[LOWER]]
-; CHECK-NEXT: [[ELSE_CMP_DST_SUB_5_UPPER:%.*]] = icmp ult i8* [[ELSE_DST_SUB_5]], [[UPPER]]
+; CHECK-NEXT: [[ELSE_DST_SUB_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -5
+; CHECK-NEXT: [[ELSE_CMP_DST_SUB_5_LOWER:%.*]] = icmp uge ptr [[ELSE_DST_SUB_5]], [[LOWER]]
+; CHECK-NEXT: [[ELSE_CMP_DST_SUB_5_UPPER:%.*]] = icmp ult ptr [[ELSE_DST_SUB_5]], [[UPPER]]
; CHECK-NEXT: [[ELSE_RES_6:%.*]] = xor i1 [[ELSE_RES_5]], [[ELSE_CMP_DST_SUB_5_LOWER]]
; CHECK-NEXT: [[ELSE_RES_7:%.*]] = xor i1 [[ELSE_RES_6]], [[ELSE_CMP_DST_SUB_5_UPPER]]
; CHECK-NEXT: ret i1 [[ELSE_RES_7]]
;
- %dst.sub.4 = getelementptr inbounds i8, i8* %dst, i64 -4
- %pre.dst.lower = icmp uge i8* %dst, %lower
- %pre.dst.upper = icmp ult i8* %dst.sub.4, %upper
+ %dst.sub.4 = getelementptr inbounds i8, ptr %dst, i64 -4
+ %pre.dst.lower = icmp uge ptr %dst, %lower
+ %pre.dst.upper = icmp ult ptr %dst.sub.4, %upper
%and = and i1 %pre.dst.lower, %pre.dst.upper
br i1 %and, label %then, label %else
then:
- %cmp.dst.lower = icmp uge i8* %dst, %lower
- %cmp.dst.upper = icmp ult i8* %dst, %upper
+ %cmp.dst.lower = icmp uge ptr %dst, %lower
+ %cmp.dst.upper = icmp ult ptr %dst, %upper
%res.1 = xor i1 %cmp.dst.lower, %cmp.dst.upper
-
- %dst.sub.3 = getelementptr inbounds i8, i8* %dst, i64 -3
- %cmp.dst.sub.3.lower = icmp uge i8* %dst.sub.3, %lower
- %cmp.dst.sub.3.upper = icmp ult i8* %dst.sub.3, %upper
+ %dst.sub.3 = getelementptr inbounds i8, ptr %dst, i64 -3
+ %cmp.dst.sub.3.lower = icmp uge ptr %dst.sub.3, %lower
+ %cmp.dst.sub.3.upper = icmp ult ptr %dst.sub.3, %upper
%res.2 = xor i1 %res.1, %cmp.dst.sub.3.lower
%res.3 = xor i1 %res.2, %cmp.dst.sub.3.upper
-
- %cmp.dst.sub.4.lower = icmp uge i8* %dst.sub.4, %lower
- %cmp.dst.sub.4.upper = icmp ult i8* %dst.sub.4, %upper
+ %cmp.dst.sub.4.lower = icmp uge ptr %dst.sub.4, %lower
+ %cmp.dst.sub.4.upper = icmp ult ptr %dst.sub.4, %upper
%res.4 = xor i1 %res.3, %cmp.dst.sub.4.lower
%res.5 = xor i1 %res.4, %cmp.dst.sub.4.upper
-
- %dst.sub.5 = getelementptr inbounds i8, i8* %dst, i64 -5
- %cmp.dst.sub.5.lower = icmp uge i8* %dst.sub.5, %lower
- %cmp.dst.sub.5.upper = icmp ult i8* %dst.sub.5, %upper
+ %dst.sub.5 = getelementptr inbounds i8, ptr %dst, i64 -5
+ %cmp.dst.sub.5.lower = icmp uge ptr %dst.sub.5, %lower
+ %cmp.dst.sub.5.upper = icmp ult ptr %dst.sub.5, %upper
%res.6 = xor i1 %res.5, %cmp.dst.sub.5.lower
%res.7 = xor i1 %res.6, %cmp.dst.sub.5.upper
-
ret i1 %res.7
else:
- %else.cmp.dst.lower = icmp uge i8* %dst, %lower
- %else.cmp.dst.upper = icmp ult i8* %dst, %upper
+ %else.cmp.dst.lower = icmp uge ptr %dst, %lower
+ %else.cmp.dst.upper = icmp ult ptr %dst, %upper
%else.res.1 = xor i1 %else.cmp.dst.lower, %else.cmp.dst.upper
-
- %else.dst.sub.3 = getelementptr inbounds i8, i8* %dst, i64 -3
- %else.cmp.dst.sub.3.lower = icmp uge i8* %else.dst.sub.3, %lower
- %else.cmp.dst.sub.3.upper = icmp ult i8* %else.dst.sub.3, %upper
+ %else.dst.sub.3 = getelementptr inbounds i8, ptr %dst, i64 -3
+ %else.cmp.dst.sub.3.lower = icmp uge ptr %else.dst.sub.3, %lower
+ %else.cmp.dst.sub.3.upper = icmp ult ptr %else.dst.sub.3, %upper
%else.res.2 = xor i1 %else.res.1, %else.cmp.dst.sub.3.lower
%else.res.3 = xor i1 %else.res.2, %else.cmp.dst.sub.3.upper
-
- %else.cmp.dst.sub.4.lower = icmp uge i8* %dst.sub.4, %lower
- %else.cmp.dst.sub.4.upper = icmp ult i8* %dst.sub.4, %upper
+ %else.cmp.dst.sub.4.lower = icmp uge ptr %dst.sub.4, %lower
+ %else.cmp.dst.sub.4.upper = icmp ult ptr %dst.sub.4, %upper
%else.res.4 = xor i1 %else.res.3, %else.cmp.dst.sub.4.lower
%else.res.5 = xor i1 %else.res.4, %else.cmp.dst.sub.4.upper
-
- %else.dst.sub.5 = getelementptr inbounds i8, i8* %dst, i64 -5
- %else.cmp.dst.sub.5.lower = icmp uge i8* %else.dst.sub.5, %lower
- %else.cmp.dst.sub.5.upper = icmp ult i8* %else.dst.sub.5, %upper
+ %else.dst.sub.5 = getelementptr inbounds i8, ptr %dst, i64 -5
+ %else.cmp.dst.sub.5.lower = icmp uge ptr %else.dst.sub.5, %lower
+ %else.cmp.dst.sub.5.upper = icmp ult ptr %else.dst.sub.5, %upper
%else.res.6 = xor i1 %else.res.5, %else.cmp.dst.sub.5.lower
%else.res.7 = xor i1 %else.res.6, %else.cmp.dst.sub.5.upper
-
ret i1 %else.res.7
}
-define i1 @n_unknown(i32* %dst, i32 %n, i32 %i) {
+define i1 @n_unknown(ptr %dst, i32 %n, i32 %i) {
; CHECK-LABEL: @n_unknown(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[SUB:%.*]] = add i32 [[N:%.*]], -1
; CHECK-NEXT: [[IDXPROM:%.*]] = zext i32 [[SUB]] to i64
-; CHECK-NEXT: [[PTR_N_SUB_1:%.*]] = getelementptr i32, i32* [[DST:%.*]], i64 [[IDXPROM]]
-; CHECK-NEXT: [[CMP_PTR_DST:%.*]] = icmp uge i32* [[PTR_N_SUB_1]], [[DST]]
+; CHECK-NEXT: [[PTR_N_SUB_1:%.*]] = getelementptr i32, ptr [[DST:%.*]], i64 [[IDXPROM]]
+; CHECK-NEXT: [[CMP_PTR_DST:%.*]] = icmp uge ptr [[PTR_N_SUB_1]], [[DST]]
; CHECK-NEXT: br i1 [[CMP_PTR_DST]], label [[PRE_BB_2:%.*]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
@@ -187,8 +175,8 @@ define i1 @n_unknown(i32* %dst, i32 %n, i32 %i) {
entry:
%sub = add i32 %n, -1
%idxprom = zext i32 %sub to i64
- %ptr.n.sub.1 = getelementptr i32, i32* %dst, i64 %idxprom
- %cmp.ptr.dst = icmp uge i32* %ptr.n.sub.1, %dst
+ %ptr.n.sub.1 = getelementptr i32, ptr %dst, i64 %idxprom
+ %cmp.ptr.dst = icmp uge ptr %ptr.n.sub.1, %dst
br i1 %cmp.ptr.dst, label %pre.bb.2, label %exit
exit:
@@ -203,13 +191,13 @@ tgt.bb:
ret i1 %cmp1
}
-define i1 @n_known_zero_due_to_nuw(i32* %dst, i32 %n, i32 %i) {
+define i1 @n_known_zero_due_to_nuw(ptr %dst, i32 %n, i32 %i) {
; CHECK-LABEL: @n_known_zero_due_to_nuw(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[SUB:%.*]] = add i32 [[N:%.*]], -1
; CHECK-NEXT: [[IDXPROM:%.*]] = zext i32 [[SUB]] to i64
-; CHECK-NEXT: [[PTR_N_SUB_1:%.*]] = getelementptr i32, i32* [[DST:%.*]], i64 [[IDXPROM]]
-; CHECK-NEXT: [[CMP_PTR_DST:%.*]] = icmp uge i32* [[PTR_N_SUB_1]], [[DST]]
+; CHECK-NEXT: [[PTR_N_SUB_1:%.*]] = getelementptr i32, ptr [[DST:%.*]], i64 [[IDXPROM]]
+; CHECK-NEXT: [[CMP_PTR_DST:%.*]] = icmp uge ptr [[PTR_N_SUB_1]], [[DST]]
; CHECK-NEXT: br i1 [[CMP_PTR_DST]], label [[PRE_BB_2:%.*]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
@@ -223,8 +211,8 @@ define i1 @n_known_zero_due_to_nuw(i32* %dst, i32 %n, i32 %i) {
entry:
%sub = add i32 %n, -1
%idxprom = zext i32 %sub to i64
- %ptr.n.sub.1 = getelementptr i32, i32* %dst, i64 %idxprom
- %cmp.ptr.dst = icmp uge i32* %ptr.n.sub.1, %dst
+ %ptr.n.sub.1 = getelementptr i32, ptr %dst, i64 %idxprom
+ %cmp.ptr.dst = icmp uge ptr %ptr.n.sub.1, %dst
br i1 %cmp.ptr.dst, label %pre.bb.2, label %exit
exit:
@@ -239,15 +227,15 @@ tgt.bb:
ret i1 %cmp1
}
-define i4 @ptr_N_signed_positive_explicit_check_constant_step(i8* %src, i8* %lower, i8* %upper, i16 %N) {
+define i4 @ptr_N_signed_positive_explicit_check_constant_step(ptr %src, ptr %lower, ptr %upper, i16 %N) {
; CHECK-LABEL: @ptr_N_signed_positive_explicit_check_constant_step(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[N_POS:%.*]] = icmp sge i16 [[N:%.*]], 0
; CHECK-NEXT: br i1 [[N_POS]], label [[ENTRY_1:%.*]], label [[TRAP_BB:%.*]]
; CHECK: entry.1:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -256,23 +244,22 @@ define i4 @ptr_N_signed_positive_explicit_check_constant_step(i8* %src, i8* %low
; CHECK-NEXT: [[STEP_ULT_N:%.*]] = icmp ult i16 1, [[N]]
; CHECK-NEXT: br i1 [[STEP_ULT_N]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 1
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 false, false
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
-
entry:
%N.pos = icmp sge i16 %N, 0
br i1 %N.pos, label %entry.1, label %trap.bb
entry.1:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -284,9 +271,9 @@ step.check:
br i1 %step.ult.N, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 1
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 1
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -295,15 +282,15 @@ exit:
}
; Same as ptr_N_signed_positive_explicit_check_constant_step, but without inbounds.
-define i4 @ptr_N_signed_positive_explicit_check_constant_step_no_inbonds(i8* %src, i8* %lower, i8* %upper, i16 %N) {
+define i4 @ptr_N_signed_positive_explicit_check_constant_step_no_inbonds(ptr %src, ptr %lower, ptr %upper, i16 %N) {
; CHECK-LABEL: @ptr_N_signed_positive_explicit_check_constant_step_no_inbonds(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[N_POS:%.*]] = icmp sge i16 [[N:%.*]], 0
; CHECK-NEXT: br i1 [[N_POS]], label [[ENTRY_1:%.*]], label [[TRAP_BB:%.*]]
; CHECK: entry.1:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr i8, i8* [[SRC:%.*]], i16 [[N]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr i8, ptr [[SRC:%.*]], i16 [[N]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -312,23 +299,22 @@ define i4 @ptr_N_signed_positive_explicit_check_constant_step_no_inbonds(i8* %sr
; CHECK-NEXT: [[STEP_ULT_N:%.*]] = icmp ult i16 1, [[N]]
; CHECK-NEXT: br i1 [[STEP_ULT_N]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr i8, i8* [[SRC]], i16 1
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr i8, ptr [[SRC]], i16 1
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
-
entry:
%N.pos = icmp sge i16 %N, 0
br i1 %N.pos, label %entry.1, label %trap.bb
entry.1:
- %src.end = getelementptr i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -340,9 +326,9 @@ step.check:
br i1 %step.ult.N, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr i8, i8* %src, i16 1
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr i8, ptr %src, i16 1
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -350,7 +336,7 @@ exit:
ret i4 3
}
-define i4 @ptr_N_and_step_signed_positive_explicit_check_constant_step(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_and_step_signed_positive_explicit_check_constant_step(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_and_step_signed_positive_explicit_check_constant_step(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[N_POS:%.*]] = icmp sge i16 [[N:%.*]], 0
@@ -358,9 +344,9 @@ define i4 @ptr_N_and_step_signed_positive_explicit_check_constant_step(i8* %src,
; CHECK-NEXT: [[AND_1:%.*]] = and i1 [[N_POS]], [[STEP_POS]]
; CHECK-NEXT: br i1 [[AND_1]], label [[ENTRY_1:%.*]], label [[TRAP_BB:%.*]]
; CHECK: entry.1:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -371,15 +357,14 @@ define i4 @ptr_N_and_step_signed_positive_explicit_check_constant_step(i8* %src,
; CHECK-NEXT: [[AND_2:%.*]] = and i1 true, [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_2]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 1
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 false, false
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
-
entry:
%N.pos = icmp sge i16 %N, 0
%step.pos = icmp sge i16 %step, 0
@@ -387,9 +372,9 @@ entry:
br i1 %and.1, label %entry.1, label %trap.bb
entry.1:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -403,9 +388,9 @@ step.check:
br i1 %and.2, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 1
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 1
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -413,15 +398,15 @@ exit:
ret i4 3
}
-define i4 @ptr_N_and_step_signed_positive_unsigned_checks_only(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_and_step_signed_positive_unsigned_checks_only(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_and_step_signed_positive_unsigned_checks_only(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N:%.*]]
-; CHECK-NEXT: [[NO_OVERFLOW:%.*]] = icmp ule i8* [[SRC]], [[SRC_END]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N:%.*]]
+; CHECK-NEXT: [[NO_OVERFLOW:%.*]] = icmp ule ptr [[SRC]], [[SRC_END]]
; CHECK-NEXT: br i1 [[NO_OVERFLOW]], label [[ENTRY_1:%.*]], label [[TRAP_BB:%.*]]
; CHECK: entry.1:
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -432,22 +417,22 @@ define i4 @ptr_N_and_step_signed_positive_unsigned_checks_only(i8* %src, i8* %lo
; CHECK-NEXT: [[AND_2:%.*]] = and i1 [[STEP_UGE_0]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_2]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 1
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 false, [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %no.overflow = icmp ule i8* %src, %src.end
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %no.overflow = icmp ule ptr %src, %src.end
br i1 %no.overflow, label %entry.1, label %trap.bb
entry.1:
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -461,9 +446,9 @@ step.check:
br i1 %and.2, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 1
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 1
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -471,12 +456,12 @@ exit:
ret i4 3
}
-define i4 @ptr_N_signed_positive(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_signed_positive(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_signed_positive(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[N_NEG:%.*]] = icmp slt i16 [[N]], 0
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_PRECOND_1:%.*]] = or i1 [[OR_PRECOND_0]], [[N_NEG]]
@@ -489,18 +474,18 @@ define i4 @ptr_N_signed_positive(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 false, false
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%N.neg = icmp slt i16 %N, 0
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
%or.precond.1 = or i1 %or.precond.0, %N.neg
@@ -516,9 +501,9 @@ step.check:
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -526,12 +511,12 @@ exit:
ret i4 3
}
-define i4 @ptr_N_could_be_negative(i8* %src, i8* %lower, i8* %upper, i8 %N, i8 %step) {
+define i4 @ptr_N_could_be_negative(ptr %src, ptr %lower, ptr %upper, i8 %N, i8 %step) {
; CHECK-LABEL: @ptr_N_could_be_negative(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB:%.*]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -542,18 +527,18 @@ define i4 @ptr_N_could_be_negative(i8* %src, i8* %lower, i8* %upper, i8 %N, i8 %
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -567,9 +552,9 @@ step.check:
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i8 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i8 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -577,13 +562,13 @@ exit:
ret i4 3
}
-define i4 @ptr_src_uge_end(i8* %src, i8* %lower, i8* %upper, i8 %N, i8 %step) {
+define i4 @ptr_src_uge_end(ptr %src, ptr %lower, ptr %upper, i8 %N, i8 %step) {
; CHECK-LABEL: @ptr_src_uge_end(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
-; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt i8* [[SRC]], [[SRC_END]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt ptr [[SRC]], [[SRC_END]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_PRECOND_1:%.*]] = or i1 [[OR_PRECOND_0]], [[CMP_OVERFLOW]]
; CHECK-NEXT: br i1 [[OR_PRECOND_1]], label [[TRAP_BB:%.*]], label [[STEP_CHECK:%.*]]
@@ -595,19 +580,19 @@ define i4 @ptr_src_uge_end(i8* %src, i8* %lower, i8* %upper, i8 %N, i8 %step) {
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
- %cmp.overflow = icmp ugt i8* %src, %src.end
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
+ %cmp.overflow = icmp ugt ptr %src, %src.end
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
%or.precond.1 = or i1 %or.precond.0, %cmp.overflow
br i1 %or.precond.1, label %trap.bb, label %step.check
@@ -622,9 +607,9 @@ step.check:
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i8 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i8 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -632,12 +617,12 @@ exit:
ret i4 3
}
-define i4 @inc_ptr_N_could_be_negative(i8* %src, i8* %lower, i8* %upper, i8 %N, i8 %step) {
+define i4 @inc_ptr_N_could_be_negative(ptr %src, ptr %lower, ptr %upper, i8 %N, i8 %step) {
; CHECK-LABEL: @inc_ptr_N_could_be_negative(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB:%.*]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -649,18 +634,18 @@ define i4 @inc_ptr_N_could_be_negative(i8* %src, i8* %lower, i8* %upper, i8 %N,
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -669,15 +654,15 @@ trap.bb:
step.check:
%step.pos = icmp uge i8 %step, 0
- %next = add nsw nuw i8 %step, 2
+ %next = add nuw nsw i8 %step, 2
%step.ult.N = icmp ult i8 %next, %N
%and.step = and i1 %step.pos, %step.ult.N
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i8 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i8 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -685,13 +670,13 @@ exit:
ret i4 3
}
-define i4 @inc_ptr_src_uge_end(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @inc_ptr_src_uge_end(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @inc_ptr_src_uge_end(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
-; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt i8* [[SRC]], [[SRC_END]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt ptr [[SRC]], [[SRC_END]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_PRECOND_1:%.*]] = or i1 [[OR_PRECOND_0]], [[CMP_OVERFLOW]]
; CHECK-NEXT: br i1 [[OR_PRECOND_1]], label [[TRAP_BB:%.*]], label [[STEP_CHECK:%.*]]
@@ -704,19 +689,19 @@ define i4 @inc_ptr_src_uge_end(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %st
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
- %cmp.overflow = icmp ugt i8* %src, %src.end
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
+ %cmp.overflow = icmp ugt ptr %src, %src.end
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
%or.precond.1 = or i1 %or.precond.0, %cmp.overflow
br i1 %or.precond.1, label %trap.bb, label %step.check
@@ -726,15 +711,15 @@ trap.bb:
step.check:
%step.pos = icmp uge i16 %step, 0
- %next = add nsw nuw i16 %step, 2
+ %next = add nuw nsw i16 %step, 2
%step.ult.N = icmp ult i16 %next, %N
%and.step = and i1 %step.pos, %step.ult.N
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -742,22 +727,22 @@ exit:
ret i4 3
}
-define i4 @inc_ptr_src_uge_end_no_nsw_add(i8* %src, i8* %lower, i8* %upper, i16 %idx, i16 %N, i16 %step) {
+define i4 @inc_ptr_src_uge_end_no_nsw_add(ptr %src, ptr %lower, ptr %upper, i16 %idx, i16 %N, i16 %step) {
; CHECK-LABEL: @inc_ptr_src_uge_end_no_nsw_add(
; CHECK-NEXT: entry.1:
; CHECK-NEXT: [[IDX_POS:%.*]] = icmp sge i16 [[IDX:%.*]], 0
; CHECK-NEXT: br i1 [[IDX_POS]], label [[ENTRY:%.*]], label [[TRAP_BB:%.*]]
; CHECK: entry:
-; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[IDX]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC_IDX]], [[LOWER:%.*]]
+; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[IDX]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC_IDX]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_SRC_START]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
; CHECK-NEXT: ret i4 2
; CHECK: step.check:
; CHECK-NEXT: [[NEXT:%.*]] = add i16 [[IDX]], 2
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 [[NEXT]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[NEXT]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT:%.*]]
; CHECK: exit:
@@ -768,8 +753,8 @@ entry.1:
br i1 %idx.pos, label %entry, label %trap.bb
entry:
- %src.idx = getelementptr inbounds i8, i8* %src, i16 %idx
- %cmp.src.start = icmp ult i8* %src.idx, %lower
+ %src.idx = getelementptr inbounds i8, ptr %src, i16 %idx
+ %cmp.src.start = icmp ult ptr %src.idx, %lower
br i1 %cmp.src.start, label %trap.bb, label %step.check
trap.bb:
@@ -777,9 +762,9 @@ trap.bb:
step.check:
%next = add i16 %idx, 2
- %src.step = getelementptr inbounds i8, i8* %src, i16 %next
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 %next
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -787,22 +772,22 @@ exit:
ret i4 3
}
-define i4 @inc_ptr_src_uge_end_no_nsw_add_sge_0(i8* %src, i8* %lower, i8* %upper, i16 %idx, i16 %N, i16 %step) {
+define i4 @inc_ptr_src_uge_end_no_nsw_add_sge_0(ptr %src, ptr %lower, ptr %upper, i16 %idx, i16 %N, i16 %step) {
; CHECK-LABEL: @inc_ptr_src_uge_end_no_nsw_add_sge_0(
; CHECK-NEXT: entry.1:
; CHECK-NEXT: [[IDX_POS:%.*]] = icmp sge i16 [[IDX:%.*]], 0
; CHECK-NEXT: br i1 [[IDX_POS]], label [[ENTRY:%.*]], label [[TRAP_BB:%.*]]
; CHECK: entry:
-; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[IDX]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC_IDX]], [[LOWER:%.*]]
+; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[IDX]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC_IDX]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_SRC_START]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
; CHECK-NEXT: ret i4 2
; CHECK: step.check:
; CHECK-NEXT: [[NEXT:%.*]] = add i16 [[IDX]], 2
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 [[NEXT]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[NEXT]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT:%.*]]
; CHECK: exit:
@@ -813,8 +798,8 @@ entry.1:
br i1 %idx.pos, label %entry, label %trap.bb
entry:
- %src.idx = getelementptr inbounds i8, i8* %src, i16 %idx
- %cmp.src.start = icmp ult i8* %src.idx, %lower
+ %src.idx = getelementptr inbounds i8, ptr %src, i16 %idx
+ %cmp.src.start = icmp ult ptr %src.idx, %lower
br i1 %cmp.src.start, label %trap.bb, label %step.check
trap.bb:
@@ -822,9 +807,9 @@ trap.bb:
step.check:
%next = add i16 %idx, 2
- %src.step = getelementptr inbounds i8, i8* %src, i16 %next
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 %next
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -832,16 +817,13 @@ exit:
ret i4 3
}
-
-
-
; N might be negative, meaning %src.end could be < %src! Cannot remove checks!
-define i4 @ptr_N_unsigned_positive(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_unsigned_positive(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_unsigned_positive(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[N_NEG:%.*]] = icmp ult i16 [[N]], 0
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_PRECOND_1:%.*]] = or i1 [[OR_PRECOND_0]], [[N_NEG]]
@@ -854,18 +836,18 @@ define i4 @ptr_N_unsigned_positive(i8* %src, i8* %lower, i8* %upper, i16 %N, i16
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%N.neg = icmp ult i16 %N, 0
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
%or.precond.1 = or i1 %or.precond.0, %N.neg
@@ -881,9 +863,9 @@ step.check:
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -891,12 +873,12 @@ exit:
ret i4 3
}
-define i4 @ptr_N_signed_positive_assume(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_signed_positive_assume(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_signed_positive_assume(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i16 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[N_NEG:%.*]] = icmp slt i16 [[N]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[N_NEG]])
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
@@ -909,18 +891,18 @@ define i4 @ptr_N_signed_positive_assume(i8* %src, i8* %lower, i8* %upper, i16 %N
; CHECK-NEXT: [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
; CHECK-NEXT: br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i16 [[STEP]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[STEP]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i16 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i16 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%N.neg = icmp slt i16 %N, 0
call void @llvm.assume(i1 %N.neg)
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
@@ -936,9 +918,9 @@ step.check:
br i1 %and.step, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i16 %step
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i16 %step
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -946,14 +928,14 @@ exit:
ret i4 3
}
-define i4 @ptr_N_step_zext_n_zext(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_step_zext_n_zext(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_step_zext_n_zext(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[N_ADD_1:%.*]] = add nuw nsw i16 [[N:%.*]], 1
; CHECK-NEXT: [[N_ADD_1_EXT:%.*]] = zext i16 [[N_ADD_1]] to i32
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i32 [[N_ADD_1_EXT]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i32 [[N_ADD_1_EXT]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB:%.*]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -964,21 +946,20 @@ define i4 @ptr_N_step_zext_n_zext(i8* %src, i8* %lower, i8* %upper, i16 %N, i16
; CHECK-NEXT: [[STEP_ULT_N:%.*]] = icmp ult i32 [[STEP_ADD_1_EXT]], [[N_ADD_1_EXT]]
; CHECK-NEXT: br i1 [[STEP_ULT_N]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i32 [[STEP_ADD_1_EXT]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 [[STEP_ADD_1_EXT]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], false
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
-
entry:
%N.add.1 = add nuw nsw i16 %N, 1
%N.add.1.ext = zext i16 %N.add.1 to i32
- %src.end = getelementptr inbounds i8, i8* %src, i32 %N.add.1.ext
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i32 %N.add.1.ext
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -992,9 +973,9 @@ step.check:
br i1 %step.ult.N, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i32 %step.add.1.ext
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i32 %step.add.1.ext
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
@@ -1002,14 +983,14 @@ exit:
ret i4 3
}
-define i4 @ptr_N_step_zext_n_zext_out_of_bounds(i8* %src, i8* %lower, i8* %upper, i16 %N, i16 %step) {
+define i4 @ptr_N_step_zext_n_zext_out_of_bounds(ptr %src, ptr %lower, ptr %upper, i16 %N, i16 %step) {
; CHECK-LABEL: @ptr_N_step_zext_n_zext_out_of_bounds(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[N_ADD_2:%.*]] = add nuw nsw i16 [[N:%.*]], 2
; CHECK-NEXT: [[N_ADD_2_EXT:%.*]] = zext i16 [[N_ADD_2]] to i32
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i32 [[N_ADD_2_EXT]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i32 [[N_ADD_2_EXT]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_PRECOND_0]], label [[TRAP_BB:%.*]], label [[STEP_CHECK:%.*]]
; CHECK: trap.bb:
@@ -1021,21 +1002,20 @@ define i4 @ptr_N_step_zext_n_zext_out_of_bounds(i8* %src, i8* %lower, i8* %upper
; CHECK-NEXT: [[STEP_ULT_N:%.*]] = icmp ult i32 [[STEP_EXT]], [[N_ADD_2_EXT]]
; CHECK-NEXT: br i1 [[STEP_ULT_N]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
; CHECK: ptr.check:
-; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i32 [[STEP_ADD_2_EXT]]
-; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult i8* [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge i8* [[SRC_STEP]], [[UPPER]]
+; CHECK-NEXT: [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 [[STEP_ADD_2_EXT]]
+; CHECK-NEXT: [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
+; CHECK-NEXT: [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
; CHECK-NEXT: [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]
; CHECK-NEXT: br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i4 3
;
-
entry:
%N.add.2 = add nuw nsw i16 %N, 2
%N.add.2.ext = zext i16 %N.add.2 to i32
- %src.end = getelementptr inbounds i8, i8* %src, i32 %N.add.2.ext
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i32 %N.add.2.ext
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.precond.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.precond.0, label %trap.bb, label %step.check
@@ -1050,9 +1030,9 @@ step.check:
br i1 %step.ult.N, label %ptr.check, label %exit
ptr.check:
- %src.step = getelementptr inbounds i8, i8* %src, i32 %step.add.2.ext
- %cmp.step.start = icmp ult i8* %src.step, %lower
- %cmp.step.end = icmp uge i8* %src.step, %upper
+ %src.step = getelementptr inbounds i8, ptr %src, i32 %step.add.2.ext
+ %cmp.step.start = icmp ult ptr %src.step, %lower
+ %cmp.step.end = icmp uge ptr %src.step, %upper
%or.check = or i1 %cmp.step.start, %cmp.step.end
br i1 %or.check, label %trap.bb, label %exit
diff --git a/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll b/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll
index f21b96ce0d676..3f56736e3b955 100644
--- a/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll
+++ b/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll
@@ -1,253 +1,247 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
-define void @pointer.to.array.test.ult.true.due.to.first.dimension([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.ult.true.due.to.first.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.ult.true.due.to.first.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 9, i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 9, i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 5, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 5, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
; CHECK-NEXT: ret void
; CHECK: if.end:
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 9, i64 3
- %c.1 = icmp ule i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 9, i64 3
+ %c.1 = icmp ule ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
if.then: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 5, i64 0
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 0
+ %c.0 = icmp ult ptr %start.0, %high
call void @use(i1 %c.0)
-
ret void
if.end: ; preds = %entry
ret void
}
-define void @pointer.to.array.test.ult.unknown.due.to.first.dimension([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.ult.unknown.due.to.first.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.ult.unknown.due.to.first.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 5, i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 5, i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 10, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 10, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
; CHECK-NEXT: ret void
; CHECK: if.end:
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 5, i64 3
- %c.1 = icmp ule i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 3
+ %c.1 = icmp ule ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
if.then: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 10, i64 0
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 10, i64 0
+ %c.0 = icmp ult ptr %start.0, %high
call void @use(i1 %c.0)
-
ret void
if.end: ; preds = %entry
ret void
}
-define void @pointer.to.array.test.ult.true.due.to.second.dimension([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.ult.true.due.to.second.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.ult.true.due.to.second.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 5, i64 1
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 5, i64 1
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 5, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 5, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
; CHECK-NEXT: ret void
; CHECK: if.end:
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 5, i64 1
- %c.1 = icmp ule i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 1
+ %c.1 = icmp ule ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
if.then: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 5, i64 0
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 0
+ %c.0 = icmp ult ptr %start.0, %high
call void @use(i1 %c.0)
-
ret void
if.end: ; preds = %entry
ret void
}
-define void @pointer.to.array.test.ult.unknown.to.second.dimension([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.ult.unknown.to.second.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.ult.unknown.to.second.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 5, i64 0
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 5, i64 0
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 5, i64 1
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 5, i64 1
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
; CHECK-NEXT: ret void
; CHECK: if.end:
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 5, i64 0
- %c.1 = icmp ule i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 0
+ %c.1 = icmp ule ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
if.then: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 5, i64 1
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 1
+ %c.0 = icmp ult ptr %start.0, %high
call void @use(i1 %c.0)
-
ret void
if.end: ; preds = %entry
ret void
}
-define void @pointer.to.array.test.not.uge.ult([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.not.uge.ult(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.not.uge.ult(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 1, i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 1, i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 10, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 10, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 1, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 1, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
if.then: ; preds = %entry
ret void
if.end: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 10, i64 0
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 10, i64 0
+ %c.0 = icmp ult ptr %start.0, %high
call void @use(i1 %c.0)
ret void
}
-define void @pointer.to.array.test.not.uge.ule([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.not.uge.ule(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.not.uge.ule(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 1, i64 3
-; CHECK-NEXT: [[C:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 1, i64 3
+; CHECK-NEXT: [[C:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 10, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp ule i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 10, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp ule ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 2, i64 1
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 2, i64 1
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_1]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 1, i64 3
- %c = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 1, i64 3
+ %c = icmp uge ptr %add.ptr.i, %high
br i1 %c, label %if.then, label %if.end
if.then: ; preds = %entry
ret void
if.end: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 10, i64 0
- %c.0 = icmp ule i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 10, i64 0
+ %c.0 = icmp ule ptr %start.0, %high
call void @use(i1 %c.0)
- %start.1 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 2, i64 1
- %c.1 = icmp ule i8* %start.1, %high
+ %start.1 = getelementptr inbounds [10 x i8], ptr %start, i64 2, i64 1
+ %c.1 = icmp ule ptr %start.1, %high
call void @use(i1 %c.1)
ret void
}
-define void @pointer.to.array.test.not.uge.ugt([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.not.uge.ugt(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.not.uge.ugt(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 1, i64 3
-; CHECK-NEXT: [[C:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 1, i64 3
+; CHECK-NEXT: [[C:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 3, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp ugt i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 3, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp ugt ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 3, i64 1
-; CHECK-NEXT: [[C_1:%.*]] = icmp ugt i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 3, i64 1
+; CHECK-NEXT: [[C_1:%.*]] = icmp ugt ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_1]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 1, i64 3
- %c = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 1, i64 3
+ %c = icmp uge ptr %add.ptr.i, %high
br i1 %c, label %if.then, label %if.end
if.then: ; preds = %entry
ret void
if.end: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 3, i64 0
- %c.0 = icmp ugt i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 3, i64 0
+ %c.0 = icmp ugt ptr %start.0, %high
call void @use(i1 %c.0)
-
- %start.1 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 3, i64 1
- %c.1 = icmp ugt i8* %start.1, %high
+ %start.1 = getelementptr inbounds [10 x i8], ptr %start, i64 3, i64 1
+ %c.1 = icmp ugt ptr %start.1, %high
call void @use(i1 %c.1)
ret void
}
-define void @pointer.to.array.test.not.uge.uge([10 x i8]* %start, i8* %high) {
+define void @pointer.to.array.test.not.uge.uge(ptr %start, ptr %high) {
; CHECK-LABEL: @pointer.to.array.test.not.uge.uge(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START:%.*]], i64 1, i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 1, i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[START]], i64 3, i64 0
-; CHECK-NEXT: [[C_0:%.*]] = icmp uge i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 3, i64 0
+; CHECK-NEXT: [[C_0:%.*]] = icmp uge ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 1, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 1, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
if.then: ; preds = %entry
ret void
if.end: ; preds = %entry
- %start.0 = getelementptr inbounds [10 x i8], [10 x i8]* %start, i64 3, i64 0
- %c.0 = icmp uge i8* %start.0, %high
+ %start.0 = getelementptr inbounds [10 x i8], ptr %start, i64 3, i64 0
+ %c.0 = icmp uge ptr %start.0, %high
call void @use(i1 %c.0)
-
ret void
}
diff --git a/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll b/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll
index 8145fa51517bc..bb0ef5293a3d3 100644
--- a/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll
+++ b/llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll
@@ -2,52 +2,53 @@
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
%struct.1 = type { i32, i64, i8 }
+%struct.2 = type { i32, [20 x i64], i8 }
-define i1 @test.ult.true.due.to.first.dimension(%struct.1* %start, i8* %high) {
+define i1 @test.ult.true.due.to.first.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @test.ult.true.due.to.first.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 6, i32 0
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i32* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 6, i32 0
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 5, i32 0
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i32* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 5, i32 0
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 6, i32 0
- %add.ptr.cast = bitcast i32* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 6, i32 0
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 5, i32 0
- %start.0.cast = bitcast i32* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 0
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.true.due.to.first.dimension.var.index.0(%struct.1* %start, i8* %high, i32 %idx) {
+define i1 @test.ult.true.due.to.first.dimension.var.index.0(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @test.ult.true.due.to.first.dimension.var.index.0(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT_PLUS_1:%.*]] = add nuw nsw i32 [[IDX:%.*]], 1
; CHECK-NEXT: [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i32* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 [[IDX_EXT]], i32 0
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i32* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 0
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
@@ -55,36 +56,36 @@ define i1 @test.ult.true.due.to.first.dimension.var.index.0(%struct.1* %start, i
entry:
%idx.ext.plus.1 = add nuw nsw i32 %idx, 1
%idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext.plus.1.ext, i32 0
- %add.ptr.cast = bitcast i32* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext.plus.1.ext, i32 0
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
%idx.ext = zext i32 %idx to i64
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 0
- %start.0.cast = bitcast i32* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 0
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.true.due.to.first.dimension.var.index.1(%struct.1* %start, i8* %high, i32 %idx) {
+define i1 @test.ult.true.due.to.first.dimension.var.index.1(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @test.ult.true.due.to.first.dimension.var.index.1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT_PLUS_1:%.*]] = add nuw nsw i32 [[IDX:%.*]], 1
; CHECK-NEXT: [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i32* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 [[IDX_EXT]], i32 1
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i64* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 1
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
@@ -92,35 +93,35 @@ define i1 @test.ult.true.due.to.first.dimension.var.index.1(%struct.1* %start, i
entry:
%idx.ext.plus.1 = add nuw nsw i32 %idx, 1
%idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext.plus.1.ext, i32 0
- %add.ptr.cast = bitcast i32* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext.plus.1.ext, i32 0
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
%idx.ext = zext i32 %idx to i64
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 1
- %start.0.cast = bitcast i64* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 1
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.true.due.to.first.dimension.var.index.2(%struct.1* %start, i8* %high, i32 %idx) {
+define i1 @test.ult.true.due.to.first.dimension.var.index.2(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @test.ult.true.due.to.first.dimension.var.index.2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT_PLUS_1:%.*]] = add nuw nsw i32 [[IDX:%.*]], 1
; CHECK-NEXT: [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i32* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 [[IDX_EXT]], i32 2
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 2
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
@@ -128,219 +129,217 @@ define i1 @test.ult.true.due.to.first.dimension.var.index.2(%struct.1* %start, i
entry:
%idx.ext.plus.1 = add nuw nsw i32 %idx, 1
%idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext.plus.1.ext, i32 0
- %add.ptr.cast = bitcast i32* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext.plus.1.ext, i32 0
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
%idx.ext = zext i32 %idx to i64
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 2
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 2
+ %c.0 = icmp ult ptr %start.0, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.unknown.due.to.first.dimension(%struct.1* %start, i8* %high) {
+define i1 @test.ult.unknown.due.to.first.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @test.ult.unknown.due.to.first.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 5, i32 0
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i32* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 5, i32 0
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 6, i32 0
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i32* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 6, i32 0
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 5, i32 0
- %add.ptr.cast = bitcast i32* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 0
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 6, i32 0
- %start.0.cast = bitcast i32* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 6, i32 0
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.true.due.to.second.dimension(%struct.1* %start, i8* %high) {
+define i1 @test.ult.true.due.to.second.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @test.ult.true.due.to.second.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 5, i32 2
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 5, i32 2
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 5, i32 1
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i64* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 5, i32 1
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 5, i32 2
- %c.1 = icmp ule i8* %add.ptr, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 2
+ %c.1 = icmp ule ptr %add.ptr, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 5, i32 1
- %start.0.cast = bitcast i64 * %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 1
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.unknown.due.to.second.dimension(%struct.1* %start, i8* %high) {
+define i1 @test.ult.unknown.due.to.second.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @test.ult.unknown.due.to.second.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 5, i32 2
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 5, i32 2
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 5, i32 2
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 5, i32 2
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 5, i32 2
- %c.1 = icmp ule i8* %add.ptr, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 2
+ %c.1 = icmp ule ptr %add.ptr, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 5, i32 2
- %c.0 = icmp ult i8* %start.0, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 2
+ %c.0 = icmp ult ptr %start.0, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.unknown.due.to.second.dimension.var.index.0(%struct.1* %start, i8* %high, i32 %idx) {
+define i1 @test.ult.unknown.due.to.second.dimension.var.index.0(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @test.ult.unknown.due.to.second.dimension.var.index.0(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX:%.*]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 [[IDX_EXT]], i32 0
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i32* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT]], i32 0
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 [[IDX_EXT]], i32 1
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i64* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 1
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
%idx.ext = zext i32 %idx to i64
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 0
- %add.ptr.cast = bitcast i32* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 0
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 1
- %start.0.cast = bitcast i64* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 1
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @test.ult.unknown.due.to.second.dimension.var.index.1(%struct.1* %start, i8* %high, i32 %idx) {
+define i1 @test.ult.unknown.due.to.second.dimension.var.index.1(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @test.ult.unknown.due.to.second.dimension.var.index.1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX:%.*]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], %struct.1* [[START:%.*]], i64 [[IDX_EXT]], i32 1
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i64* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT]], i32 1
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], %struct.1* [[START]], i64 [[IDX_EXT]], i32 2
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 2
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
%idx.ext = zext i32 %idx to i64
- %add.ptr = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 1
- %add.ptr.cast = bitcast i64* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 1
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.1, %struct.1* %start, i64 %idx.ext, i32 2
- %c.0 = icmp ult i8* %start.0, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext, i32 2
+ %c.0 = icmp ult ptr %start.0, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-%struct.2 = type { i32, [20 x i64], i8 }
-
-define i1 @ptr.int.struct.test.ult.true.due.to.first.dimension(%struct.2* %start, i8* %high) {
+define i1 @ptr.int.struct.test.ult.true.due.to.first.dimension(ptr %start, ptr %high) {
; CHECK-LABEL: @ptr.int.struct.test.ult.true.due.to.first.dimension(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], %struct.2* [[START:%.*]], i64 6, i32 1, i32 5
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i64* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], ptr [[START:%.*]], i64 6, i32 1, i32 5
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], %struct.2* [[START]], i64 6, i32 0
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i32* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], ptr [[START]], i64 6, i32 0
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
;
entry:
- %add.ptr = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 1, i32 5
- %add.ptr.cast = bitcast i64* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i32 5
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.0 = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 0
- %start.0.cast = bitcast i32* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+if.then:
+ %start.0 = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 0
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @ptr.int.struct.test.ult.true.due.to.third.dimension.var.index(%struct.2* %start, i8* %high, i32 %idx) {
+define i1 @ptr.int.struct.test.ult.true.due.to.third.dimension.var.index(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @ptr.int.struct.test.ult.true.due.to.third.dimension.var.index(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT_PLUS_1:%.*]] = add nuw nsw i32 [[IDX:%.*]], 1
; CHECK-NEXT: [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], %struct.2* [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i64* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], ptr [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], %struct.2* [[START]], i64 6, i32 1, i64 [[IDX_EXT]]
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i64* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], ptr [[START]], i64 6, i32 1, i64 [[IDX_EXT]]
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
@@ -348,36 +347,36 @@ define i1 @ptr.int.struct.test.ult.true.due.to.third.dimension.var.index(%struct
entry:
%idx.ext.plus.1 = add nuw nsw i32 %idx, 1
%idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
- %add.ptr = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext
- %add.ptr.cast = bitcast i64* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
%idx.ext = zext i32 %idx to i64
- %start.0 = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 1, i64 %idx.ext
- %start.0.cast = bitcast i64* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+ %start.0 = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i64 %idx.ext
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @ptr.int.struct.test.ult.due.to.second.dimension.var.index(%struct.2* %start, i8* %high, i32 %idx) {
+define i1 @ptr.int.struct.test.ult.due.to.second.dimension.var.index(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @ptr.int.struct.test.ult.due.to.second.dimension.var.index(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT_PLUS_1:%.*]] = add nuw nsw i32 [[IDX:%.*]], 1
; CHECK-NEXT: [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], %struct.2* [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i64* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], ptr [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], %struct.2* [[START]], i64 6, i32 0
-; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast i32* [[START_0]] to i8*
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0_CAST]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], ptr [[START]], i64 6, i32 0
+; CHECK-NEXT: [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
@@ -385,35 +384,35 @@ define i1 @ptr.int.struct.test.ult.due.to.second.dimension.var.index(%struct.2*
entry:
%idx.ext.plus.1 = add nuw nsw i32 %idx, 1
%idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
- %add.ptr = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext
- %add.ptr.cast = bitcast i64* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
%idx.ext = zext i32 %idx to i64
- %start.0 = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 0
- %start.0.cast = bitcast i32* %start.0 to i8*
- %c.0 = icmp ult i8* %start.0.cast, %high
+ %start.0 = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 0
+ %start.0.cast = bitcast ptr %start.0 to ptr
+ %c.0 = icmp ult ptr %start.0.cast, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
-define i1 @ptr.int.struct.test.ult.unknown.due.to.second.dimension.var.index(%struct.2* %start, i8* %high, i32 %idx) {
+define i1 @ptr.int.struct.test.ult.unknown.due.to.second.dimension.var.index(ptr %start, ptr %high, i32 %idx) {
; CHECK-LABEL: @ptr.int.struct.test.ult.unknown.due.to.second.dimension.var.index(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT_PLUS_1:%.*]] = add nuw nsw i32 [[IDX:%.*]], 1
; CHECK-NEXT: [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], %struct.2* [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
-; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast i64* [[ADD_PTR]] to i8*
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[ADD_PTR_CAST]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], ptr [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
+; CHECK-NEXT: [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
-; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], %struct.2* [[START]], i64 6, i32 2
-; CHECK-NEXT: [[C_0:%.*]] = icmp ult i8* [[START_0]], [[HIGH]]
+; CHECK-NEXT: [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], ptr [[START]], i64 6, i32 2
+; CHECK-NEXT: [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
; CHECK-NEXT: ret i1 [[C_0]]
; CHECK: if.end:
; CHECK-NEXT: ret i1 true
@@ -421,17 +420,17 @@ define i1 @ptr.int.struct.test.ult.unknown.due.to.second.dimension.var.index(%st
entry:
%idx.ext.plus.1 = add nuw nsw i32 %idx, 1
%idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
- %add.ptr = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext
- %add.ptr.cast = bitcast i64* %add.ptr to i8*
- %c.1 = icmp ule i8* %add.ptr.cast, %high
+ %add.ptr = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext
+ %add.ptr.cast = bitcast ptr %add.ptr to ptr
+ %c.1 = icmp ule ptr %add.ptr.cast, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
%idx.ext = zext i32 %idx to i64
- %start.0 = getelementptr inbounds %struct.2, %struct.2* %start, i64 6, i32 2
- %c.0 = icmp ult i8* %start.0, %high
+ %start.0 = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 2
+ %c.0 = icmp ult ptr %start.0, %high
ret i1 %c.0
-if.end: ; preds = %entry
- ret i1 1
+if.end:
+ ret i1 true
}
diff --git a/llvm/test/Transforms/ConstraintElimination/geps-signed-predicates.ll b/llvm/test/Transforms/ConstraintElimination/geps-signed-predicates.ll
index 5b1e9d7be1bf8..8c28555461978 100644
--- a/llvm/test/Transforms/ConstraintElimination/geps-signed-predicates.ll
+++ b/llvm/test/Transforms/ConstraintElimination/geps-signed-predicates.ll
@@ -1,90 +1,90 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
-define i32 @test.slt(i32* readonly %src, i32* readnone %min, i32* readnone %max) {
+define i32 @test.slt(ptr readonly %src, ptr readnone %min, ptr readnone %max) {
; CHECK-LABEL: @test.slt(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp slt i32* [[SRC:%.*]], [[MIN:%.*]]
+; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp slt ptr [[SRC:%.*]], [[MIN:%.*]]
; CHECK-NEXT: br i1 [[C_MIN_0]], label [[TRAP:%.*]], label [[CHECK_0_MAX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret i32 10
; CHECK: check.0.max:
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt i32* [[SRC]], [[MAX:%.*]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt ptr [[SRC]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_MAX_0]], label [[CHECK_3_MIN:%.*]], label [[TRAP]]
; CHECK: check.3.min:
-; CHECK-NEXT: [[L0:%.*]] = load i32, i32* [[SRC]], align 4
-; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 3
-; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp slt i32* [[ADD_PTR_I36]], [[MIN]]
+; CHECK-NEXT: [[L0:%.*]] = load i32, ptr [[SRC]], align 4
+; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 3
+; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp slt ptr [[ADD_PTR_I36]], [[MIN]]
; CHECK-NEXT: br i1 [[C_3_MIN]], label [[TRAP]], label [[CHECK_3_MAX:%.*]]
; CHECK: check.3.max:
-; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp slt i32* [[ADD_PTR_I36]], [[MAX]]
+; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp slt ptr [[ADD_PTR_I36]], [[MAX]]
; CHECK-NEXT: br i1 [[C_3_MAX]], label [[CHECK_1_MIN:%.*]], label [[TRAP]]
; CHECK: check.1.min:
-; CHECK-NEXT: [[L1:%.*]] = load i32, i32* [[ADD_PTR_I36]], align 4
-; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 1
-; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp slt i32* [[ADD_PTR_I29]], [[MIN]]
+; CHECK-NEXT: [[L1:%.*]] = load i32, ptr [[ADD_PTR_I36]], align 4
+; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 1
+; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp slt ptr [[ADD_PTR_I29]], [[MIN]]
; CHECK-NEXT: br i1 [[C_1_MIN]], label [[TRAP]], label [[CHECK_1_MAX:%.*]]
; CHECK: check.1.max:
-; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp slt i32* [[ADD_PTR_I29]], [[MAX]]
+; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp slt ptr [[ADD_PTR_I29]], [[MAX]]
; CHECK-NEXT: br i1 [[C_1_MAX]], label [[CHECK_2_MIN:%.*]], label [[TRAP]]
; CHECK: check.2.min:
-; CHECK-NEXT: [[L2:%.*]] = load i32, i32* [[ADD_PTR_I29]], align 4
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 2
-; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp slt i32* [[ADD_PTR_I]], [[MIN]]
+; CHECK-NEXT: [[L2:%.*]] = load i32, ptr [[ADD_PTR_I29]], align 4
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 2
+; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp slt ptr [[ADD_PTR_I]], [[MIN]]
; CHECK-NEXT: br i1 [[C_2_MIN]], label [[TRAP]], label [[CHECK_2_MAX:%.*]]
; CHECK: check.2.max:
-; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp slt i32* [[ADD_PTR_I]], [[MAX]]
+; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp slt ptr [[ADD_PTR_I]], [[MAX]]
; CHECK-NEXT: br i1 [[C_2_MAX]], label [[EXIT:%.*]], label [[TRAP]]
; CHECK: exit:
-; CHECK-NEXT: [[L3:%.*]] = load i32, i32* [[ADD_PTR_I]], align 4
+; CHECK-NEXT: [[L3:%.*]] = load i32, ptr [[ADD_PTR_I]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[L1]], [[L0]]
; CHECK-NEXT: [[ADD8:%.*]] = add nsw i32 [[ADD]], [[L2]]
; CHECK-NEXT: [[ADD9:%.*]] = add nsw i32 [[ADD8]], [[L3]]
; CHECK-NEXT: ret i32 [[ADD9]]
;
check.0.min:
- %c.min.0 = icmp slt i32* %src, %min
+ %c.min.0 = icmp slt ptr %src, %min
br i1 %c.min.0, label %trap, label %check.0.max
-trap: ; preds = %check.2.max, %check.2.min, %check.1.max, %check.1.min, %check.3.max, %check.3.min, %check.0.max, %check.0.min
+trap:
ret i32 10
-check.0.max: ; preds = %check.0.min
- %c.max.0 = icmp slt i32* %src, %max
+check.0.max:
+ %c.max.0 = icmp slt ptr %src, %max
br i1 %c.max.0, label %check.3.min, label %trap
-check.3.min: ; preds = %check.0.max
- %l0 = load i32, i32* %src, align 4
- %add.ptr.i36 = getelementptr inbounds i32, i32* %src, i64 3
- %c.3.min = icmp slt i32* %add.ptr.i36, %min
+check.3.min:
+ %l0 = load i32, ptr %src, align 4
+ %add.ptr.i36 = getelementptr inbounds i32, ptr %src, i64 3
+ %c.3.min = icmp slt ptr %add.ptr.i36, %min
br i1 %c.3.min, label %trap, label %check.3.max
-check.3.max: ; preds = %check.3.min
- %c.3.max = icmp slt i32* %add.ptr.i36, %max
+check.3.max:
+ %c.3.max = icmp slt ptr %add.ptr.i36, %max
br i1 %c.3.max, label %check.1.min, label %trap
-check.1.min: ; preds = %check.3.max
- %l1 = load i32, i32* %add.ptr.i36, align 4
- %add.ptr.i29 = getelementptr inbounds i32, i32* %src, i64 1
- %c.1.min = icmp slt i32* %add.ptr.i29, %min
+check.1.min:
+ %l1 = load i32, ptr %add.ptr.i36, align 4
+ %add.ptr.i29 = getelementptr inbounds i32, ptr %src, i64 1
+ %c.1.min = icmp slt ptr %add.ptr.i29, %min
br i1 %c.1.min, label %trap, label %check.1.max
-check.1.max: ; preds = %check.1.min
- %c.1.max = icmp slt i32* %add.ptr.i29, %max
+check.1.max:
+ %c.1.max = icmp slt ptr %add.ptr.i29, %max
br i1 %c.1.max, label %check.2.min, label %trap
-check.2.min: ; preds = %check.1.max
- %l2 = load i32, i32* %add.ptr.i29, align 4
- %add.ptr.i = getelementptr inbounds i32, i32* %src, i64 2
- %c.2.min = icmp slt i32* %add.ptr.i, %min
+check.2.min:
+ %l2 = load i32, ptr %add.ptr.i29, align 4
+ %add.ptr.i = getelementptr inbounds i32, ptr %src, i64 2
+ %c.2.min = icmp slt ptr %add.ptr.i, %min
br i1 %c.2.min, label %trap, label %check.2.max
-check.2.max: ; preds = %check.2.min
- %c.2.max = icmp slt i32* %add.ptr.i, %max
+check.2.max:
+ %c.2.max = icmp slt ptr %add.ptr.i, %max
br i1 %c.2.max, label %exit, label %trap
-exit: ; preds = %check.2.max
- %l3 = load i32, i32* %add.ptr.i, align 4
+exit:
+ %l3 = load i32, ptr %add.ptr.i, align 4
%add = add nsw i32 %l1, %l0
%add8 = add nsw i32 %add, %l2
%add9 = add nsw i32 %add8, %l3
@@ -92,435 +92,417 @@ exit: ; preds = %check.2.max
}
; Same as test.slt, but without inbounds.
-define i32 @test.slt_no_inbounds(i32* readonly %src, i32* readnone %min, i32* readnone %max) {
+define i32 @test.slt_no_inbounds(ptr readonly %src, ptr readnone %min, ptr readnone %max) {
; CHECK-LABEL: @test.slt_no_inbounds(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp slt i32* [[SRC:%.*]], [[MIN:%.*]]
+; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp slt ptr [[SRC:%.*]], [[MIN:%.*]]
; CHECK-NEXT: br i1 [[C_MIN_0]], label [[TRAP:%.*]], label [[CHECK_0_MAX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret i32 10
; CHECK: check.0.max:
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt i32* [[SRC]], [[MAX:%.*]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt ptr [[SRC]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_MAX_0]], label [[CHECK_3_MIN:%.*]], label [[TRAP]]
; CHECK: check.3.min:
-; CHECK-NEXT: [[L0:%.*]] = load i32, i32* [[SRC]], align 4
-; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr i32, i32* [[SRC]], i64 3
-; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp slt i32* [[ADD_PTR_I36]], [[MIN]]
+; CHECK-NEXT: [[L0:%.*]] = load i32, ptr [[SRC]], align 4
+; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr i32, ptr [[SRC]], i64 3
+; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp slt ptr [[ADD_PTR_I36]], [[MIN]]
; CHECK-NEXT: br i1 [[C_3_MIN]], label [[TRAP]], label [[CHECK_3_MAX:%.*]]
; CHECK: check.3.max:
-; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp slt i32* [[ADD_PTR_I36]], [[MAX]]
+; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp slt ptr [[ADD_PTR_I36]], [[MAX]]
; CHECK-NEXT: br i1 [[C_3_MAX]], label [[CHECK_1_MIN:%.*]], label [[TRAP]]
; CHECK: check.1.min:
-; CHECK-NEXT: [[L1:%.*]] = load i32, i32* [[ADD_PTR_I36]], align 4
-; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr i32, i32* [[SRC]], i64 1
-; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp slt i32* [[ADD_PTR_I29]], [[MIN]]
+; CHECK-NEXT: [[L1:%.*]] = load i32, ptr [[ADD_PTR_I36]], align 4
+; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr i32, ptr [[SRC]], i64 1
+; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp slt ptr [[ADD_PTR_I29]], [[MIN]]
; CHECK-NEXT: br i1 [[C_1_MIN]], label [[TRAP]], label [[CHECK_1_MAX:%.*]]
; CHECK: check.1.max:
-; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp slt i32* [[ADD_PTR_I29]], [[MAX]]
+; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp slt ptr [[ADD_PTR_I29]], [[MAX]]
; CHECK-NEXT: br i1 [[C_1_MAX]], label [[CHECK_2_MIN:%.*]], label [[TRAP]]
; CHECK: check.2.min:
-; CHECK-NEXT: [[L2:%.*]] = load i32, i32* [[ADD_PTR_I29]], align 4
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i32, i32* [[SRC]], i64 2
-; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp slt i32* [[ADD_PTR_I]], [[MIN]]
+; CHECK-NEXT: [[L2:%.*]] = load i32, ptr [[ADD_PTR_I29]], align 4
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i32, ptr [[SRC]], i64 2
+; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp slt ptr [[ADD_PTR_I]], [[MIN]]
; CHECK-NEXT: br i1 [[C_2_MIN]], label [[TRAP]], label [[CHECK_2_MAX:%.*]]
; CHECK: check.2.max:
-; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp slt i32* [[ADD_PTR_I]], [[MAX]]
+; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp slt ptr [[ADD_PTR_I]], [[MAX]]
; CHECK-NEXT: br i1 [[C_2_MAX]], label [[EXIT:%.*]], label [[TRAP]]
; CHECK: exit:
-; CHECK-NEXT: [[L3:%.*]] = load i32, i32* [[ADD_PTR_I]], align 4
+; CHECK-NEXT: [[L3:%.*]] = load i32, ptr [[ADD_PTR_I]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[L1]], [[L0]]
; CHECK-NEXT: [[ADD8:%.*]] = add nsw i32 [[ADD]], [[L2]]
; CHECK-NEXT: [[ADD9:%.*]] = add nsw i32 [[ADD8]], [[L3]]
; CHECK-NEXT: ret i32 [[ADD9]]
;
check.0.min:
- %c.min.0 = icmp slt i32* %src, %min
+ %c.min.0 = icmp slt ptr %src, %min
br i1 %c.min.0, label %trap, label %check.0.max
-trap: ; preds = %check.2.max, %check.2.min, %check.1.max, %check.1.min, %check.3.max, %check.3.min, %check.0.max, %check.0.min
+trap:
ret i32 10
-check.0.max: ; preds = %check.0.min
- %c.max.0 = icmp slt i32* %src, %max
+check.0.max:
+ %c.max.0 = icmp slt ptr %src, %max
br i1 %c.max.0, label %check.3.min, label %trap
-check.3.min: ; preds = %check.0.max
- %l0 = load i32, i32* %src, align 4
- %add.ptr.i36 = getelementptr i32, i32* %src, i64 3
- %c.3.min = icmp slt i32* %add.ptr.i36, %min
+check.3.min:
+ %l0 = load i32, ptr %src, align 4
+ %add.ptr.i36 = getelementptr i32, ptr %src, i64 3
+ %c.3.min = icmp slt ptr %add.ptr.i36, %min
br i1 %c.3.min, label %trap, label %check.3.max
-check.3.max: ; preds = %check.3.min
- %c.3.max = icmp slt i32* %add.ptr.i36, %max
+check.3.max:
+ %c.3.max = icmp slt ptr %add.ptr.i36, %max
br i1 %c.3.max, label %check.1.min, label %trap
-check.1.min: ; preds = %check.3.max
- %l1 = load i32, i32* %add.ptr.i36, align 4
- %add.ptr.i29 = getelementptr i32, i32* %src, i64 1
- %c.1.min = icmp slt i32* %add.ptr.i29, %min
+check.1.min:
+ %l1 = load i32, ptr %add.ptr.i36, align 4
+ %add.ptr.i29 = getelementptr i32, ptr %src, i64 1
+ %c.1.min = icmp slt ptr %add.ptr.i29, %min
br i1 %c.1.min, label %trap, label %check.1.max
-check.1.max: ; preds = %check.1.min
- %c.1.max = icmp slt i32* %add.ptr.i29, %max
+check.1.max:
+ %c.1.max = icmp slt ptr %add.ptr.i29, %max
br i1 %c.1.max, label %check.2.min, label %trap
-check.2.min: ; preds = %check.1.max
- %l2 = load i32, i32* %add.ptr.i29, align 4
- %add.ptr.i = getelementptr i32, i32* %src, i64 2
- %c.2.min = icmp slt i32* %add.ptr.i, %min
+check.2.min:
+ %l2 = load i32, ptr %add.ptr.i29, align 4
+ %add.ptr.i = getelementptr i32, ptr %src, i64 2
+ %c.2.min = icmp slt ptr %add.ptr.i, %min
br i1 %c.2.min, label %trap, label %check.2.max
-check.2.max: ; preds = %check.2.min
- %c.2.max = icmp slt i32* %add.ptr.i, %max
+check.2.max:
+ %c.2.max = icmp slt ptr %add.ptr.i, %max
br i1 %c.2.max, label %exit, label %trap
-exit: ; preds = %check.2.max
- %l3 = load i32, i32* %add.ptr.i, align 4
+exit:
+ %l3 = load i32, ptr %add.ptr.i, align 4
%add = add nsw i32 %l1, %l0
%add8 = add nsw i32 %add, %l2
%add9 = add nsw i32 %add8, %l3
ret i32 %add9
}
-
-define void @test.not.sge.slt(i8* %start, i8* %low, i8* %high) {
+define void @test.not.sge.slt(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.sge.slt(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp sge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp sge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[T_0:%.*]] = icmp slt i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp slt ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[T_1:%.*]] = icmp slt i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[T_1:%.*]] = icmp slt ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_1]])
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[T_2:%.*]] = icmp slt i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[T_2:%.*]] = icmp slt ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_2]])
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[T_3:%.*]] = icmp slt i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[T_3:%.*]] = icmp slt ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_3]])
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[C_4:%.*]] = icmp slt i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[C_4:%.*]] = icmp slt ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_4]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp sge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp sge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %t.0 = icmp slt i8* %start, %high
+if.end:
+ %t.0 = icmp slt ptr %start, %high
call void @use(i1 %t.0)
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %t.1 = icmp slt i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %t.1 = icmp slt ptr %start.1, %high
call void @use(i1 %t.1)
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %t.2 = icmp slt i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %t.2 = icmp slt ptr %start.2, %high
call void @use(i1 %t.2)
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %t.3 = icmp slt i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %t.3 = icmp slt ptr %start.3, %high
call void @use(i1 %t.3)
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %c.4 = icmp slt i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %c.4 = icmp slt ptr %start.4, %high
call void @use(i1 %c.4)
ret void
}
; Same as test.not.sge.slt, but without inbounds GEPs.
-define void @test.not.sge.slt_no_inbounds(i8* %start, i8* %low, i8* %high) {
+define void @test.not.sge.slt_no_inbounds(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.sge.slt_no_inbounds(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp sge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp sge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[T_0:%.*]] = icmp slt i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp slt ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[T_1:%.*]] = icmp slt i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[T_1:%.*]] = icmp slt ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_1]])
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[T_2:%.*]] = icmp slt i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[T_2:%.*]] = icmp slt ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_2]])
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[T_3:%.*]] = icmp slt i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[T_3:%.*]] = icmp slt ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_3]])
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[C_4:%.*]] = icmp slt i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[C_4:%.*]] = icmp slt ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_4]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr i8, i8* %start, i64 3
- %c.1 = icmp sge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr i8, ptr %start, i64 3
+ %c.1 = icmp sge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %t.0 = icmp slt i8* %start, %high
+if.end:
+ %t.0 = icmp slt ptr %start, %high
call void @use(i1 %t.0)
- %start.1 = getelementptr i8, i8* %start, i64 1
- %t.1 = icmp slt i8* %start.1, %high
+ %start.1 = getelementptr i8, ptr %start, i64 1
+ %t.1 = icmp slt ptr %start.1, %high
call void @use(i1 %t.1)
- %start.2 = getelementptr i8, i8* %start, i64 2
- %t.2 = icmp slt i8* %start.2, %high
+ %start.2 = getelementptr i8, ptr %start, i64 2
+ %t.2 = icmp slt ptr %start.2, %high
call void @use(i1 %t.2)
- %start.3 = getelementptr i8, i8* %start, i64 3
- %t.3 = icmp slt i8* %start.3, %high
+ %start.3 = getelementptr i8, ptr %start, i64 3
+ %t.3 = icmp slt ptr %start.3, %high
call void @use(i1 %t.3)
- %start.4 = getelementptr i8, i8* %start, i64 4
- %c.4 = icmp slt i8* %start.4, %high
+ %start.4 = getelementptr i8, ptr %start, i64 4
+ %c.4 = icmp slt ptr %start.4, %high
call void @use(i1 %c.4)
ret void
}
-define void @test.not.sge.sle(i8* %start, i8* %low, i8* %high) {
+define void @test.not.sge.sle(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.sge.sle(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp sge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp sge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[T_0:%.*]] = icmp sle i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp sle ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[T_1:%.*]] = icmp sle i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[T_1:%.*]] = icmp sle ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_1]])
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[T_2:%.*]] = icmp sle i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[T_2:%.*]] = icmp sle ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_2]])
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[T_3:%.*]] = icmp sle i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[T_3:%.*]] = icmp sle ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_3]])
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[T_4:%.*]] = icmp sle i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[T_4:%.*]] = icmp sle ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_4]])
-; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 5
-; CHECK-NEXT: [[C_5:%.*]] = icmp sle i8* [[START_5]], [[HIGH]]
+; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
+; CHECK-NEXT: [[C_5:%.*]] = icmp sle ptr [[START_5]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_5]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp sge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp sge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %t.0 = icmp sle i8* %start, %high
+if.end:
+ %t.0 = icmp sle ptr %start, %high
call void @use(i1 %t.0)
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %t.1 = icmp sle i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %t.1 = icmp sle ptr %start.1, %high
call void @use(i1 %t.1)
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %t.2 = icmp sle i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %t.2 = icmp sle ptr %start.2, %high
call void @use(i1 %t.2)
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %t.3 = icmp sle i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %t.3 = icmp sle ptr %start.3, %high
call void @use(i1 %t.3)
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %t.4 = icmp sle i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %t.4 = icmp sle ptr %start.4, %high
call void @use(i1 %t.4)
-
- %start.5 = getelementptr inbounds i8, i8* %start, i64 5
- %c.5 = icmp sle i8* %start.5, %high
+ %start.5 = getelementptr inbounds i8, ptr %start, i64 5
+ %c.5 = icmp sle ptr %start.5, %high
call void @use(i1 %c.5)
-
ret void
}
-define void @test.not.sge.sgt(i8* %start, i8* %low, i8* %high) {
+define void @test.not.sge.sgt(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.sge.sgt(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp sge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp sge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[F_0:%.*]] = icmp sgt i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[F_0:%.*]] = icmp sgt ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[F_1:%.*]] = icmp sgt i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[F_1:%.*]] = icmp sgt ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_1]])
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[F_2:%.*]] = icmp sgt i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[F_2:%.*]] = icmp sgt ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_2]])
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[F_3:%.*]] = icmp sgt i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[F_3:%.*]] = icmp sgt ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_3]])
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[F_4:%.*]] = icmp sgt i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[F_4:%.*]] = icmp sgt ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_4]])
-; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 5
-; CHECK-NEXT: [[C_5:%.*]] = icmp sgt i8* [[START_5]], [[HIGH]]
+; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
+; CHECK-NEXT: [[C_5:%.*]] = icmp sgt ptr [[START_5]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_5]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp sge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp sge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %f.0 = icmp sgt i8* %start, %high
+if.end:
+ %f.0 = icmp sgt ptr %start, %high
call void @use(i1 %f.0)
-
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %f.1 = icmp sgt i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %f.1 = icmp sgt ptr %start.1, %high
call void @use(i1 %f.1)
-
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %f.2 = icmp sgt i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %f.2 = icmp sgt ptr %start.2, %high
call void @use(i1 %f.2)
-
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %f.3 = icmp sgt i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %f.3 = icmp sgt ptr %start.3, %high
call void @use(i1 %f.3)
-
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %f.4 = icmp sgt i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %f.4 = icmp sgt ptr %start.4, %high
call void @use(i1 %f.4)
-
- %start.5 = getelementptr inbounds i8, i8* %start, i64 5
- %c.5 = icmp sgt i8* %start.5, %high
+ %start.5 = getelementptr inbounds i8, ptr %start, i64 5
+ %c.5 = icmp sgt ptr %start.5, %high
call void @use(i1 %c.5)
-
ret void
}
-define void @test.not.sge.sge(i8* %start, i8* %low, i8* %high) {
+define void @test.not.sge.sge(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.sge.sge(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp sge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp sge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[F_0:%.*]] = icmp sgt i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[F_0:%.*]] = icmp sgt ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[F_1:%.*]] = icmp sge i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[F_1:%.*]] = icmp sge ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_1]])
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[F_2:%.*]] = icmp sge i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[F_2:%.*]] = icmp sge ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_2]])
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[F_3:%.*]] = icmp sge i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[F_3:%.*]] = icmp sge ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_3]])
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[C_4:%.*]] = icmp sge i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[C_4:%.*]] = icmp sge ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_4]])
-; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 5
-; CHECK-NEXT: [[C_5:%.*]] = icmp sge i8* [[START_5]], [[HIGH]]
+; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
+; CHECK-NEXT: [[C_5:%.*]] = icmp sge ptr [[START_5]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_5]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp sge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp sge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %f.0 = icmp sgt i8* %start, %high
+if.end:
+ %f.0 = icmp sgt ptr %start, %high
call void @use(i1 %f.0)
-
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %f.1 = icmp sge i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %f.1 = icmp sge ptr %start.1, %high
call void @use(i1 %f.1)
-
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %f.2 = icmp sge i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %f.2 = icmp sge ptr %start.2, %high
call void @use(i1 %f.2)
-
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %f.3 = icmp sge i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %f.3 = icmp sge ptr %start.3, %high
call void @use(i1 %f.3)
-
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %c.4 = icmp sge i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %c.4 = icmp sge ptr %start.4, %high
call void @use(i1 %c.4)
-
- %start.5 = getelementptr inbounds i8, i8* %start, i64 5
- %c.5 = icmp sge i8* %start.5, %high
+ %start.5 = getelementptr inbounds i8, ptr %start, i64 5
+ %c.5 = icmp sge ptr %start.5, %high
call void @use(i1 %c.5)
-
ret void
}
-define void @test.not.sge.sge.nonconst(i8* %start, i8* %low, i8* %high, i8 %off) {
+define void @test.not.sge.sge.nonconst(ptr %start, ptr %low, ptr %high, i8 %off) {
; CHECK-LABEL: @test.not.sge.sge.nonconst(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i8 [[OFF:%.*]]
-; CHECK-NEXT: [[C_1:%.*]] = icmp sge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i8 [[OFF:%.*]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp sge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_OFF_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i8 [[OFF]]
-; CHECK-NEXT: [[T_0:%.*]] = icmp sge i8* [[START_OFF_2]], [[HIGH]]
+; CHECK-NEXT: [[START_OFF_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i8 [[OFF]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp sge ptr [[START_OFF_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_0]])
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[C_0:%.*]] = icmp sge i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[C_0:%.*]] = icmp sge ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
-; CHECK-NEXT: [[START_OFF:%.*]] = getelementptr inbounds i8, i8* [[START]], i8 [[OFF]]
-; CHECK-NEXT: [[F_0:%.*]] = icmp sge i8* [[START_OFF]], [[HIGH]]
+; CHECK-NEXT: [[START_OFF:%.*]] = getelementptr inbounds i8, ptr [[START]], i8 [[OFF]]
+; CHECK-NEXT: [[F_0:%.*]] = icmp sge ptr [[START_OFF]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_0]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i8 %off
- %c.1 = icmp sge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i8 %off
+ %c.1 = icmp sge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.off.2 = getelementptr inbounds i8, i8* %start, i8 %off
- %t.0 = icmp sge i8* %start.off.2, %high
+if.then:
+ %start.off.2 = getelementptr inbounds i8, ptr %start, i8 %off
+ %t.0 = icmp sge ptr %start.off.2, %high
call void @use(i1 %t.0)
-
ret void
-if.end: ; preds = %entry
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %c.0 = icmp sge i8* %start.1, %high
+if.end:
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %c.0 = icmp sge ptr %start.1, %high
call void @use(i1 %c.0)
-
- %start.off = getelementptr inbounds i8, i8* %start, i8 %off
- %f.0 = icmp sge i8* %start.off, %high
+ %start.off = getelementptr inbounds i8, ptr %start, i8 %off
+ %f.0 = icmp sge ptr %start.off, %high
call void @use(i1 %f.0)
-
ret void
}
; Test which requires decomposing GEP %ptr, SHL().
-define void @test.slt.gep.shl(i32* readonly %src, i32* readnone %max, i8 %idx) {
+define void @test.slt.gep.shl(ptr readonly %src, ptr readnone %max, i8 %idx) {
; CHECK-LABEL: @test.slt.gep.shl(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, i32* [[SRC:%.*]], i32 10
-; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp sgt i32* [[ADD_10]], [[MAX:%.*]]
+; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, ptr [[SRC:%.*]], i32 10
+; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp sgt ptr [[ADD_10]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_ADD_10_MAX]], label [[TRAP:%.*]], label [[CHECK_IDX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret void
@@ -529,65 +511,61 @@ define void @test.slt.gep.shl(i32* readonly %src, i32* readnone %max, i8 %idx) {
; CHECK-NEXT: br i1 [[CMP]], label [[CHECK_MAX:%.*]], label [[TRAP]]
; CHECK: check.max:
; CHECK-NEXT: [[IDX_SHL_1:%.*]] = shl nuw i8 [[IDX]], 1
-; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_1]]
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt i32* [[ADD_PTR_SHL_1]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_1]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt ptr [[ADD_PTR_SHL_1]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_0]])
; CHECK-NEXT: [[IDX_SHL_2:%.*]] = shl nuw i8 [[IDX]], 2
-; CHECK-NEXT: [[ADD_PTR_SHL_2:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_2]]
-; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp slt i32* [[ADD_PTR_SHL_2]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_2:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_2]]
+; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp slt ptr [[ADD_PTR_SHL_2]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_1]])
; CHECK-NEXT: [[IDX_SHL_NOT_NUW:%.*]] = shl i8 [[IDX]], 1
-; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_NOT_NUW]]
-; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp slt i32* [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_NOT_NUW]]
+; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp slt ptr [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_2]])
; CHECK-NEXT: [[IDX_SHL_3:%.*]] = shl nuw i8 [[IDX]], 3
-; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_3]]
-; CHECK-NEXT: [[C_MAX_3:%.*]] = icmp slt i32* [[ADD_PTR_SHL_3]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_3]]
+; CHECK-NEXT: [[C_MAX_3:%.*]] = icmp slt ptr [[ADD_PTR_SHL_3]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_3]])
; CHECK-NEXT: ret void
;
check.0.min:
- %add.10 = getelementptr inbounds i32, i32* %src, i32 10
- %c.add.10.max = icmp sgt i32* %add.10, %max
+ %add.10 = getelementptr inbounds i32, ptr %src, i32 10
+ %c.add.10.max = icmp sgt ptr %add.10, %max
br i1 %c.add.10.max, label %trap, label %check.idx
trap:
ret void
-check.idx: ; preds = %check.0.min
+check.idx:
%cmp = icmp slt i8 %idx, 5
br i1 %cmp, label %check.max, label %trap
-check.max: ; preds = %check.0.min
+check.max:
%idx.shl.1 = shl nuw i8 %idx, 1
- %add.ptr.shl.1 = getelementptr inbounds i32, i32* %src, i8 %idx.shl.1
- %c.max.0 = icmp slt i32* %add.ptr.shl.1, %max
+ %add.ptr.shl.1 = getelementptr inbounds i32, ptr %src, i8 %idx.shl.1
+ %c.max.0 = icmp slt ptr %add.ptr.shl.1, %max
call void @use(i1 %c.max.0)
-
%idx.shl.2 = shl nuw i8 %idx, 2
- %add.ptr.shl.2 = getelementptr inbounds i32, i32* %src, i8 %idx.shl.2
- %c.max.1 = icmp slt i32* %add.ptr.shl.2, %max
+ %add.ptr.shl.2 = getelementptr inbounds i32, ptr %src, i8 %idx.shl.2
+ %c.max.1 = icmp slt ptr %add.ptr.shl.2, %max
call void @use(i1 %c.max.1)
-
%idx.shl.not.nuw = shl i8 %idx, 1
- %add.ptr.shl.not.nuw = getelementptr inbounds i32, i32* %src, i8 %idx.shl.not.nuw
- %c.max.2 = icmp slt i32* %add.ptr.shl.not.nuw, %max
+ %add.ptr.shl.not.nuw = getelementptr inbounds i32, ptr %src, i8 %idx.shl.not.nuw
+ %c.max.2 = icmp slt ptr %add.ptr.shl.not.nuw, %max
call void @use(i1 %c.max.2)
-
%idx.shl.3 = shl nuw i8 %idx, 3
- %add.ptr.shl.3 = getelementptr inbounds i32, i32* %src, i8 %idx.shl.3
- %c.max.3 = icmp slt i32* %add.ptr.shl.3, %max
+ %add.ptr.shl.3 = getelementptr inbounds i32, ptr %src, i8 %idx.shl.3
+ %c.max.3 = icmp slt ptr %add.ptr.shl.3, %max
call void @use(i1 %c.max.3)
-
ret void
}
; Test which requires decomposing GEP %ptr, ZEXT(SHL()).
-define void @test.slt.gep.shl.zext(i32* readonly %src, i32* readnone %max, i32 %idx, i32 %j) {
+define void @test.slt.gep.shl.zext(ptr readonly %src, ptr readnone %max, i32 %idx, i32 %j) {
; CHECK-LABEL: @test.slt.gep.shl.zext(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, i32* [[SRC:%.*]], i32 10
-; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp sgt i32* [[ADD_10]], [[MAX:%.*]]
+; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, ptr [[SRC:%.*]], i32 10
+; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp sgt ptr [[ADD_10]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_ADD_10_MAX]], label [[TRAP:%.*]], label [[CHECK_IDX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret void
@@ -597,61 +575,58 @@ define void @test.slt.gep.shl.zext(i32* readonly %src, i32* readnone %max, i32 %
; CHECK: check.max:
; CHECK-NEXT: [[IDX_SHL:%.*]] = shl nuw i32 [[IDX]], 1
; CHECK-NEXT: [[EXT_1:%.*]] = zext i32 [[IDX_SHL]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[EXT_1]]
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt i32* [[ADD_PTR_SHL]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_1]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp slt ptr [[ADD_PTR_SHL]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_0]])
; CHECK-NEXT: [[IDX_SHL_NOT_NUW:%.*]] = shl i32 [[IDX]], 1
; CHECK-NEXT: [[EXT_2:%.*]] = zext i32 [[IDX_SHL_NOT_NUW]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[EXT_2]]
-; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp slt i32* [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_2]]
+; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp slt ptr [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_1]])
; CHECK-NEXT: [[IDX_SHL_3:%.*]] = shl nuw i32 [[IDX]], 2
; CHECK-NEXT: [[EXT_3:%.*]] = zext i32 [[IDX_SHL_3]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[EXT_3]]
-; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp slt i32* [[ADD_PTR_SHL_3]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_3]]
+; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp slt ptr [[ADD_PTR_SHL_3]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_2]])
; CHECK-NEXT: ret void
;
check.0.min:
- %add.10 = getelementptr inbounds i32, i32* %src, i32 10
- %c.add.10.max = icmp sgt i32* %add.10, %max
+ %add.10 = getelementptr inbounds i32, ptr %src, i32 10
+ %c.add.10.max = icmp sgt ptr %add.10, %max
br i1 %c.add.10.max, label %trap, label %check.idx
trap:
ret void
-check.idx: ; preds = %check.0.min
+check.idx:
%cmp = icmp slt i32 %idx, 5
br i1 %cmp, label %check.max, label %trap
-check.max: ; preds = %check.0.min
+check.max:
%idx.shl = shl nuw i32 %idx, 1
%ext.1 = zext i32 %idx.shl to i64
- %add.ptr.shl = getelementptr inbounds i32, i32* %src, i64 %ext.1
- %c.max.0 = icmp slt i32* %add.ptr.shl, %max
+ %add.ptr.shl = getelementptr inbounds i32, ptr %src, i64 %ext.1
+ %c.max.0 = icmp slt ptr %add.ptr.shl, %max
call void @use(i1 %c.max.0)
-
%idx.shl.not.nuw = shl i32 %idx, 1
%ext.2 = zext i32 %idx.shl.not.nuw to i64
- %add.ptr.shl.not.nuw = getelementptr inbounds i32, i32* %src, i64 %ext.2
- %c.max.1 = icmp slt i32* %add.ptr.shl.not.nuw, %max
+ %add.ptr.shl.not.nuw = getelementptr inbounds i32, ptr %src, i64 %ext.2
+ %c.max.1 = icmp slt ptr %add.ptr.shl.not.nuw, %max
call void @use(i1 %c.max.1)
-
%idx.shl.3 = shl nuw i32 %idx, 2
%ext.3 = zext i32 %idx.shl.3 to i64
- %add.ptr.shl.3 = getelementptr inbounds i32, i32* %src, i64 %ext.3
- %c.max.2 = icmp slt i32* %add.ptr.shl.3, %max
+ %add.ptr.shl.3 = getelementptr inbounds i32, ptr %src, i64 %ext.3
+ %c.max.2 = icmp slt ptr %add.ptr.shl.3, %max
call void @use(i1 %c.max.2)
-
ret void
}
; Make sure non-constant shift amounts are handled correctly.
-define i1 @test.slt.gep.shl.nonconst.zext(i16 %B, i16* readonly %src, i16* readnone %max, i16 %idx, i16 %j) {
+define i1 @test.slt.gep.shl.nonconst.zext(i16 %B, ptr readonly %src, ptr readnone %max, i16 %idx, i16 %j) {
; CHECK-LABEL: @test.slt.gep.shl.nonconst.zext(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i16, i16* [[SRC:%.*]], i16 10
-; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp sgt i16* [[ADD_10]], [[MAX:%.*]]
+; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i16, ptr [[SRC:%.*]], i16 10
+; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp sgt ptr [[ADD_10]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_ADD_10_MAX]], label [[EXIT_1:%.*]], label [[CHECK_IDX:%.*]]
; CHECK: exit.1:
; CHECK-NEXT: ret i1 true
@@ -661,41 +636,40 @@ define i1 @test.slt.gep.shl.nonconst.zext(i16 %B, i16* readonly %src, i16* readn
; CHECK: check.max:
; CHECK-NEXT: [[IDX_SHL:%.*]] = shl nuw i16 [[IDX]], [[B:%.*]]
; CHECK-NEXT: [[EXT:%.*]] = zext i16 [[IDX_SHL]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i16, i16* [[SRC]], i64 [[EXT]]
-; CHECK-NEXT: [[C_MAX:%.*]] = icmp slt i16* [[ADD_PTR_SHL]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i16, ptr [[SRC]], i64 [[EXT]]
+; CHECK-NEXT: [[C_MAX:%.*]] = icmp slt ptr [[ADD_PTR_SHL]], [[MAX]]
; CHECK-NEXT: ret i1 [[C_MAX]]
; CHECK: trap:
; CHECK-NEXT: [[IDX_SHL_1:%.*]] = shl nuw i16 [[IDX]], [[B]]
; CHECK-NEXT: [[EXT_1:%.*]] = zext i16 [[IDX_SHL_1]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i16, i16* [[SRC]], i64 [[EXT_1]]
-; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp slt i16* [[ADD_PTR_SHL_1]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i16, ptr [[SRC]], i64 [[EXT_1]]
+; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp slt ptr [[ADD_PTR_SHL_1]], [[MAX]]
; CHECK-NEXT: ret i1 [[C_MAX_1]]
;
check.0.min:
- %add.10 = getelementptr inbounds i16, i16* %src, i16 10
- %c.add.10.max = icmp sgt i16* %add.10, %max
+ %add.10 = getelementptr inbounds i16, ptr %src, i16 10
+ %c.add.10.max = icmp sgt ptr %add.10, %max
br i1 %c.add.10.max, label %exit.1, label %check.idx
exit.1:
ret i1 true
-
-check.idx: ; preds = %check.0.min
+check.idx:
%cmp = icmp slt i16 %idx, 5
br i1 %cmp, label %check.max, label %trap
-check.max: ; preds = %check.idx
+check.max:
%idx.shl = shl nuw i16 %idx, %B
%ext = zext i16 %idx.shl to i64
- %add.ptr.shl = getelementptr inbounds i16, i16* %src, i64 %ext
- %c.max = icmp slt i16* %add.ptr.shl, %max
+ %add.ptr.shl = getelementptr inbounds i16, ptr %src, i64 %ext
+ %c.max = icmp slt ptr %add.ptr.shl, %max
ret i1 %c.max
-trap: ; preds = %check.idx, %check.0.min
+trap:
%idx.shl.1 = shl nuw i16 %idx, %B
%ext.1 = zext i16 %idx.shl.1 to i64
- %add.ptr.shl.1 = getelementptr inbounds i16, i16* %src, i64 %ext.1
- %c.max.1 = icmp slt i16* %add.ptr.shl.1, %max
+ %add.ptr.shl.1 = getelementptr inbounds i16, ptr %src, i64 %ext.1
+ %c.max.1 = icmp slt ptr %add.ptr.shl.1, %max
ret i1 %c.max.1
}
diff --git a/llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll b/llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll
index e88a470d4a3f3..1590d7cb6d783 100644
--- a/llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll
+++ b/llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll
@@ -1,90 +1,90 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
-define i32 @test.ult(i32* readonly %src, i32* readnone %min, i32* readnone %max) {
+define i32 @test.ult(ptr readonly %src, ptr readnone %min, ptr readnone %max) {
; CHECK-LABEL: @test.ult(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp ult i32* [[SRC:%.*]], [[MIN:%.*]]
+; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp ult ptr [[SRC:%.*]], [[MIN:%.*]]
; CHECK-NEXT: br i1 [[C_MIN_0]], label [[TRAP:%.*]], label [[CHECK_0_MAX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret i32 10
; CHECK: check.0.max:
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult i32* [[SRC]], [[MAX:%.*]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult ptr [[SRC]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_MAX_0]], label [[CHECK_3_MIN:%.*]], label [[TRAP]]
; CHECK: check.3.min:
-; CHECK-NEXT: [[L0:%.*]] = load i32, i32* [[SRC]], align 4
-; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 3
-; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp ult i32* [[ADD_PTR_I36]], [[MIN]]
+; CHECK-NEXT: [[L0:%.*]] = load i32, ptr [[SRC]], align 4
+; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 3
+; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I36]], [[MIN]]
; CHECK-NEXT: br i1 false, label [[TRAP]], label [[CHECK_3_MAX:%.*]]
; CHECK: check.3.max:
-; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp ult i32* [[ADD_PTR_I36]], [[MAX]]
+; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I36]], [[MAX]]
; CHECK-NEXT: br i1 [[C_3_MAX]], label [[CHECK_1_MIN:%.*]], label [[TRAP]]
; CHECK: check.1.min:
-; CHECK-NEXT: [[L1:%.*]] = load i32, i32* [[ADD_PTR_I36]], align 4
-; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 1
-; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp ult i32* [[ADD_PTR_I29]], [[MIN]]
+; CHECK-NEXT: [[L1:%.*]] = load i32, ptr [[ADD_PTR_I36]], align 4
+; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 1
+; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I29]], [[MIN]]
; CHECK-NEXT: br i1 false, label [[TRAP]], label [[CHECK_1_MAX:%.*]]
; CHECK: check.1.max:
-; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp ult i32* [[ADD_PTR_I29]], [[MAX]]
+; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I29]], [[MAX]]
; CHECK-NEXT: br i1 true, label [[CHECK_2_MIN:%.*]], label [[TRAP]]
; CHECK: check.2.min:
-; CHECK-NEXT: [[L2:%.*]] = load i32, i32* [[ADD_PTR_I29]], align 4
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 2
-; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp ult i32* [[ADD_PTR_I]], [[MIN]]
+; CHECK-NEXT: [[L2:%.*]] = load i32, ptr [[ADD_PTR_I29]], align 4
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 2
+; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I]], [[MIN]]
; CHECK-NEXT: br i1 false, label [[TRAP]], label [[CHECK_2_MAX:%.*]]
; CHECK: check.2.max:
-; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp ult i32* [[ADD_PTR_I]], [[MAX]]
+; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I]], [[MAX]]
; CHECK-NEXT: br i1 true, label [[EXIT:%.*]], label [[TRAP]]
; CHECK: exit:
-; CHECK-NEXT: [[L3:%.*]] = load i32, i32* [[ADD_PTR_I]], align 4
+; CHECK-NEXT: [[L3:%.*]] = load i32, ptr [[ADD_PTR_I]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[L1]], [[L0]]
; CHECK-NEXT: [[ADD8:%.*]] = add nsw i32 [[ADD]], [[L2]]
; CHECK-NEXT: [[ADD9:%.*]] = add nsw i32 [[ADD8]], [[L3]]
; CHECK-NEXT: ret i32 [[ADD9]]
;
check.0.min:
- %c.min.0 = icmp ult i32* %src, %min
+ %c.min.0 = icmp ult ptr %src, %min
br i1 %c.min.0, label %trap, label %check.0.max
-trap: ; preds = %check.2.max, %check.2.min, %check.1.max, %check.1.min, %check.3.max, %check.3.min, %check.0.max, %check.0.min
+trap:
ret i32 10
-check.0.max: ; preds = %check.0.min
- %c.max.0 = icmp ult i32* %src, %max
+check.0.max:
+ %c.max.0 = icmp ult ptr %src, %max
br i1 %c.max.0, label %check.3.min, label %trap
-check.3.min: ; preds = %check.0.max
- %l0 = load i32, i32* %src, align 4
- %add.ptr.i36 = getelementptr inbounds i32, i32* %src, i64 3
- %c.3.min = icmp ult i32* %add.ptr.i36, %min
+check.3.min:
+ %l0 = load i32, ptr %src, align 4
+ %add.ptr.i36 = getelementptr inbounds i32, ptr %src, i64 3
+ %c.3.min = icmp ult ptr %add.ptr.i36, %min
br i1 %c.3.min, label %trap, label %check.3.max
-check.3.max: ; preds = %check.3.min
- %c.3.max = icmp ult i32* %add.ptr.i36, %max
+check.3.max:
+ %c.3.max = icmp ult ptr %add.ptr.i36, %max
br i1 %c.3.max, label %check.1.min, label %trap
-check.1.min: ; preds = %check.3.max
- %l1 = load i32, i32* %add.ptr.i36, align 4
- %add.ptr.i29 = getelementptr inbounds i32, i32* %src, i64 1
- %c.1.min = icmp ult i32* %add.ptr.i29, %min
+check.1.min:
+ %l1 = load i32, ptr %add.ptr.i36, align 4
+ %add.ptr.i29 = getelementptr inbounds i32, ptr %src, i64 1
+ %c.1.min = icmp ult ptr %add.ptr.i29, %min
br i1 %c.1.min, label %trap, label %check.1.max
-check.1.max: ; preds = %check.1.min
- %c.1.max = icmp ult i32* %add.ptr.i29, %max
+check.1.max:
+ %c.1.max = icmp ult ptr %add.ptr.i29, %max
br i1 %c.1.max, label %check.2.min, label %trap
-check.2.min: ; preds = %check.1.max
- %l2 = load i32, i32* %add.ptr.i29, align 4
- %add.ptr.i = getelementptr inbounds i32, i32* %src, i64 2
- %c.2.min = icmp ult i32* %add.ptr.i, %min
+check.2.min:
+ %l2 = load i32, ptr %add.ptr.i29, align 4
+ %add.ptr.i = getelementptr inbounds i32, ptr %src, i64 2
+ %c.2.min = icmp ult ptr %add.ptr.i, %min
br i1 %c.2.min, label %trap, label %check.2.max
-check.2.max: ; preds = %check.2.min
- %c.2.max = icmp ult i32* %add.ptr.i, %max
+check.2.max:
+ %c.2.max = icmp ult ptr %add.ptr.i, %max
br i1 %c.2.max, label %exit, label %trap
-exit: ; preds = %check.2.max
- %l3 = load i32, i32* %add.ptr.i, align 4
+exit:
+ %l3 = load i32, ptr %add.ptr.i, align 4
%add = add nsw i32 %l1, %l0
%add8 = add nsw i32 %add, %l2
%add9 = add nsw i32 %add8, %l3
@@ -92,435 +92,417 @@ exit: ; preds = %check.2.max
}
; Same as test.ult, but without inbounds.
-define i32 @test.ult_no_inbounds(i32* readonly %src, i32* readnone %min, i32* readnone %max) {
+define i32 @test.ult_no_inbounds(ptr readonly %src, ptr readnone %min, ptr readnone %max) {
; CHECK-LABEL: @test.ult_no_inbounds(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp ult i32* [[SRC:%.*]], [[MIN:%.*]]
+; CHECK-NEXT: [[C_MIN_0:%.*]] = icmp ult ptr [[SRC:%.*]], [[MIN:%.*]]
; CHECK-NEXT: br i1 [[C_MIN_0]], label [[TRAP:%.*]], label [[CHECK_0_MAX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret i32 10
; CHECK: check.0.max:
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult i32* [[SRC]], [[MAX:%.*]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult ptr [[SRC]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_MAX_0]], label [[CHECK_3_MIN:%.*]], label [[TRAP]]
; CHECK: check.3.min:
-; CHECK-NEXT: [[L0:%.*]] = load i32, i32* [[SRC]], align 4
-; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr i32, i32* [[SRC]], i64 3
-; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp ult i32* [[ADD_PTR_I36]], [[MIN]]
+; CHECK-NEXT: [[L0:%.*]] = load i32, ptr [[SRC]], align 4
+; CHECK-NEXT: [[ADD_PTR_I36:%.*]] = getelementptr i32, ptr [[SRC]], i64 3
+; CHECK-NEXT: [[C_3_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I36]], [[MIN]]
; CHECK-NEXT: br i1 [[C_3_MIN]], label [[TRAP]], label [[CHECK_3_MAX:%.*]]
; CHECK: check.3.max:
-; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp ult i32* [[ADD_PTR_I36]], [[MAX]]
+; CHECK-NEXT: [[C_3_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I36]], [[MAX]]
; CHECK-NEXT: br i1 [[C_3_MAX]], label [[CHECK_1_MIN:%.*]], label [[TRAP]]
; CHECK: check.1.min:
-; CHECK-NEXT: [[L1:%.*]] = load i32, i32* [[ADD_PTR_I36]], align 4
-; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr i32, i32* [[SRC]], i64 1
-; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp ult i32* [[ADD_PTR_I29]], [[MIN]]
+; CHECK-NEXT: [[L1:%.*]] = load i32, ptr [[ADD_PTR_I36]], align 4
+; CHECK-NEXT: [[ADD_PTR_I29:%.*]] = getelementptr i32, ptr [[SRC]], i64 1
+; CHECK-NEXT: [[C_1_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I29]], [[MIN]]
; CHECK-NEXT: br i1 [[C_1_MIN]], label [[TRAP]], label [[CHECK_1_MAX:%.*]]
; CHECK: check.1.max:
-; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp ult i32* [[ADD_PTR_I29]], [[MAX]]
+; CHECK-NEXT: [[C_1_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I29]], [[MAX]]
; CHECK-NEXT: br i1 [[C_1_MAX]], label [[CHECK_2_MIN:%.*]], label [[TRAP]]
; CHECK: check.2.min:
-; CHECK-NEXT: [[L2:%.*]] = load i32, i32* [[ADD_PTR_I29]], align 4
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i32, i32* [[SRC]], i64 2
-; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp ult i32* [[ADD_PTR_I]], [[MIN]]
+; CHECK-NEXT: [[L2:%.*]] = load i32, ptr [[ADD_PTR_I29]], align 4
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i32, ptr [[SRC]], i64 2
+; CHECK-NEXT: [[C_2_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I]], [[MIN]]
; CHECK-NEXT: br i1 [[C_2_MIN]], label [[TRAP]], label [[CHECK_2_MAX:%.*]]
; CHECK: check.2.max:
-; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp ult i32* [[ADD_PTR_I]], [[MAX]]
+; CHECK-NEXT: [[C_2_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I]], [[MAX]]
; CHECK-NEXT: br i1 [[C_2_MAX]], label [[EXIT:%.*]], label [[TRAP]]
; CHECK: exit:
-; CHECK-NEXT: [[L3:%.*]] = load i32, i32* [[ADD_PTR_I]], align 4
+; CHECK-NEXT: [[L3:%.*]] = load i32, ptr [[ADD_PTR_I]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[L1]], [[L0]]
; CHECK-NEXT: [[ADD8:%.*]] = add nsw i32 [[ADD]], [[L2]]
; CHECK-NEXT: [[ADD9:%.*]] = add nsw i32 [[ADD8]], [[L3]]
; CHECK-NEXT: ret i32 [[ADD9]]
;
check.0.min:
- %c.min.0 = icmp ult i32* %src, %min
+ %c.min.0 = icmp ult ptr %src, %min
br i1 %c.min.0, label %trap, label %check.0.max
-trap: ; preds = %check.2.max, %check.2.min, %check.1.max, %check.1.min, %check.3.max, %check.3.min, %check.0.max, %check.0.min
+trap:
ret i32 10
-check.0.max: ; preds = %check.0.min
- %c.max.0 = icmp ult i32* %src, %max
+check.0.max:
+ %c.max.0 = icmp ult ptr %src, %max
br i1 %c.max.0, label %check.3.min, label %trap
-check.3.min: ; preds = %check.0.max
- %l0 = load i32, i32* %src, align 4
- %add.ptr.i36 = getelementptr i32, i32* %src, i64 3
- %c.3.min = icmp ult i32* %add.ptr.i36, %min
+check.3.min:
+ %l0 = load i32, ptr %src, align 4
+ %add.ptr.i36 = getelementptr i32, ptr %src, i64 3
+ %c.3.min = icmp ult ptr %add.ptr.i36, %min
br i1 %c.3.min, label %trap, label %check.3.max
-check.3.max: ; preds = %check.3.min
- %c.3.max = icmp ult i32* %add.ptr.i36, %max
+check.3.max:
+ %c.3.max = icmp ult ptr %add.ptr.i36, %max
br i1 %c.3.max, label %check.1.min, label %trap
-check.1.min: ; preds = %check.3.max
- %l1 = load i32, i32* %add.ptr.i36, align 4
- %add.ptr.i29 = getelementptr i32, i32* %src, i64 1
- %c.1.min = icmp ult i32* %add.ptr.i29, %min
+check.1.min:
+ %l1 = load i32, ptr %add.ptr.i36, align 4
+ %add.ptr.i29 = getelementptr i32, ptr %src, i64 1
+ %c.1.min = icmp ult ptr %add.ptr.i29, %min
br i1 %c.1.min, label %trap, label %check.1.max
-check.1.max: ; preds = %check.1.min
- %c.1.max = icmp ult i32* %add.ptr.i29, %max
+check.1.max:
+ %c.1.max = icmp ult ptr %add.ptr.i29, %max
br i1 %c.1.max, label %check.2.min, label %trap
-check.2.min: ; preds = %check.1.max
- %l2 = load i32, i32* %add.ptr.i29, align 4
- %add.ptr.i = getelementptr i32, i32* %src, i64 2
- %c.2.min = icmp ult i32* %add.ptr.i, %min
+check.2.min:
+ %l2 = load i32, ptr %add.ptr.i29, align 4
+ %add.ptr.i = getelementptr i32, ptr %src, i64 2
+ %c.2.min = icmp ult ptr %add.ptr.i, %min
br i1 %c.2.min, label %trap, label %check.2.max
-check.2.max: ; preds = %check.2.min
- %c.2.max = icmp ult i32* %add.ptr.i, %max
+check.2.max:
+ %c.2.max = icmp ult ptr %add.ptr.i, %max
br i1 %c.2.max, label %exit, label %trap
-exit: ; preds = %check.2.max
- %l3 = load i32, i32* %add.ptr.i, align 4
+exit:
+ %l3 = load i32, ptr %add.ptr.i, align 4
%add = add nsw i32 %l1, %l0
%add8 = add nsw i32 %add, %l2
%add9 = add nsw i32 %add8, %l3
ret i32 %add9
}
-
-define void @test.not.uge.ult(i8* %start, i8* %low, i8* %high) {
+define void @test.not.uge.ult(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.uge.ult(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[T_0:%.*]] = icmp ult i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp ult ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[T_1:%.*]] = icmp ult i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[T_1:%.*]] = icmp ult ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[T_2:%.*]] = icmp ult i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[T_2:%.*]] = icmp ult ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[T_3:%.*]] = icmp ult i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[T_3:%.*]] = icmp ult ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[C_4:%.*]] = icmp ult i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[C_4:%.*]] = icmp ult ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_4]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %t.0 = icmp ult i8* %start, %high
+if.end:
+ %t.0 = icmp ult ptr %start, %high
call void @use(i1 %t.0)
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %t.1 = icmp ult i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %t.1 = icmp ult ptr %start.1, %high
call void @use(i1 %t.1)
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %t.2 = icmp ult i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %t.2 = icmp ult ptr %start.2, %high
call void @use(i1 %t.2)
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %t.3 = icmp ult i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %t.3 = icmp ult ptr %start.3, %high
call void @use(i1 %t.3)
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %c.4 = icmp ult i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %c.4 = icmp ult ptr %start.4, %high
call void @use(i1 %c.4)
ret void
}
; Same as test.not.uge.ult, but without inbounds GEPs.
-define void @test.not.uge.ult_no_inbounds(i8* %start, i8* %low, i8* %high) {
+define void @test.not.uge.ult_no_inbounds(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.uge.ult_no_inbounds(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[T_0:%.*]] = icmp ult i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp ult ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_0]])
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[T_1:%.*]] = icmp ult i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[T_1:%.*]] = icmp ult ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_1]])
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[T_2:%.*]] = icmp ult i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[T_2:%.*]] = icmp ult ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_2]])
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[T_3:%.*]] = icmp ult i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[T_3:%.*]] = icmp ult ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_3]])
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[C_4:%.*]] = icmp ult i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[C_4:%.*]] = icmp ult ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_4]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr i8, i8* %start, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr i8, ptr %start, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %t.0 = icmp ult i8* %start, %high
+if.end:
+ %t.0 = icmp ult ptr %start, %high
call void @use(i1 %t.0)
- %start.1 = getelementptr i8, i8* %start, i64 1
- %t.1 = icmp ult i8* %start.1, %high
+ %start.1 = getelementptr i8, ptr %start, i64 1
+ %t.1 = icmp ult ptr %start.1, %high
call void @use(i1 %t.1)
- %start.2 = getelementptr i8, i8* %start, i64 2
- %t.2 = icmp ult i8* %start.2, %high
+ %start.2 = getelementptr i8, ptr %start, i64 2
+ %t.2 = icmp ult ptr %start.2, %high
call void @use(i1 %t.2)
- %start.3 = getelementptr i8, i8* %start, i64 3
- %t.3 = icmp ult i8* %start.3, %high
+ %start.3 = getelementptr i8, ptr %start, i64 3
+ %t.3 = icmp ult ptr %start.3, %high
call void @use(i1 %t.3)
- %start.4 = getelementptr i8, i8* %start, i64 4
- %c.4 = icmp ult i8* %start.4, %high
+ %start.4 = getelementptr i8, ptr %start, i64 4
+ %c.4 = icmp ult ptr %start.4, %high
call void @use(i1 %c.4)
ret void
}
-define void @test.not.uge.ule(i8* %start, i8* %low, i8* %high) {
+define void @test.not.uge.ule(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.uge.ule(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[T_0:%.*]] = icmp ule i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp ule ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[T_1:%.*]] = icmp ule i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[T_1:%.*]] = icmp ule ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[T_2:%.*]] = icmp ule i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[T_2:%.*]] = icmp ule ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[T_3:%.*]] = icmp ule i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[T_3:%.*]] = icmp ule ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[T_4:%.*]] = icmp ule i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[T_4:%.*]] = icmp ule ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 5
-; CHECK-NEXT: [[C_5:%.*]] = icmp ule i8* [[START_5]], [[HIGH]]
+; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
+; CHECK-NEXT: [[C_5:%.*]] = icmp ule ptr [[START_5]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_5]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %t.0 = icmp ule i8* %start, %high
+if.end:
+ %t.0 = icmp ule ptr %start, %high
call void @use(i1 %t.0)
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %t.1 = icmp ule i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %t.1 = icmp ule ptr %start.1, %high
call void @use(i1 %t.1)
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %t.2 = icmp ule i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %t.2 = icmp ule ptr %start.2, %high
call void @use(i1 %t.2)
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %t.3 = icmp ule i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %t.3 = icmp ule ptr %start.3, %high
call void @use(i1 %t.3)
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %t.4 = icmp ule i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %t.4 = icmp ule ptr %start.4, %high
call void @use(i1 %t.4)
-
- %start.5 = getelementptr inbounds i8, i8* %start, i64 5
- %c.5 = icmp ule i8* %start.5, %high
+ %start.5 = getelementptr inbounds i8, ptr %start, i64 5
+ %c.5 = icmp ule ptr %start.5, %high
call void @use(i1 %c.5)
-
ret void
}
-define void @test.not.uge.ugt(i8* %start, i8* %low, i8* %high) {
+define void @test.not.uge.ugt(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.uge.ugt(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[F_0:%.*]] = icmp ugt i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[F_0:%.*]] = icmp ugt ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[F_1:%.*]] = icmp ugt i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[F_1:%.*]] = icmp ugt ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[F_2:%.*]] = icmp ugt i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[F_2:%.*]] = icmp ugt ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[F_3:%.*]] = icmp ugt i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[F_3:%.*]] = icmp ugt ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[F_4:%.*]] = icmp ugt i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[F_4:%.*]] = icmp ugt ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 5
-; CHECK-NEXT: [[C_5:%.*]] = icmp ugt i8* [[START_5]], [[HIGH]]
+; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
+; CHECK-NEXT: [[C_5:%.*]] = icmp ugt ptr [[START_5]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_5]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %f.0 = icmp ugt i8* %start, %high
+if.end:
+ %f.0 = icmp ugt ptr %start, %high
call void @use(i1 %f.0)
-
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %f.1 = icmp ugt i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %f.1 = icmp ugt ptr %start.1, %high
call void @use(i1 %f.1)
-
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %f.2 = icmp ugt i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %f.2 = icmp ugt ptr %start.2, %high
call void @use(i1 %f.2)
-
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %f.3 = icmp ugt i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %f.3 = icmp ugt ptr %start.3, %high
call void @use(i1 %f.3)
-
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %f.4 = icmp ugt i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %f.4 = icmp ugt ptr %start.4, %high
call void @use(i1 %f.4)
-
- %start.5 = getelementptr inbounds i8, i8* %start, i64 5
- %c.5 = icmp ugt i8* %start.5, %high
+ %start.5 = getelementptr inbounds i8, ptr %start, i64 5
+ %c.5 = icmp ugt ptr %start.5, %high
call void @use(i1 %c.5)
-
ret void
}
-define void @test.not.uge.uge(i8* %start, i8* %low, i8* %high) {
+define void @test.not.uge.uge(ptr %start, ptr %low, ptr %high) {
; CHECK-LABEL: @test.not.uge.uge(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i64 3
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[F_0:%.*]] = icmp ugt i8* [[START]], [[HIGH]]
+; CHECK-NEXT: [[F_0:%.*]] = icmp ugt ptr [[START]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[F_1:%.*]] = icmp uge i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[F_1:%.*]] = icmp uge ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 2
-; CHECK-NEXT: [[F_2:%.*]] = icmp uge i8* [[START_2]], [[HIGH]]
+; CHECK-NEXT: [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
+; CHECK-NEXT: [[F_2:%.*]] = icmp uge ptr [[START_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 3
-; CHECK-NEXT: [[F_3:%.*]] = icmp uge i8* [[START_3]], [[HIGH]]
+; CHECK-NEXT: [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
+; CHECK-NEXT: [[F_3:%.*]] = icmp uge ptr [[START_3]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 false)
-; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 4
-; CHECK-NEXT: [[C_4:%.*]] = icmp uge i8* [[START_4]], [[HIGH]]
+; CHECK-NEXT: [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
+; CHECK-NEXT: [[C_4:%.*]] = icmp uge ptr [[START_4]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_4]])
-; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 5
-; CHECK-NEXT: [[C_5:%.*]] = icmp uge i8* [[START_5]], [[HIGH]]
+; CHECK-NEXT: [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
+; CHECK-NEXT: [[C_5:%.*]] = icmp uge ptr [[START_5]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_5]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i64 3
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
+if.then:
ret void
-if.end: ; preds = %entry
- %f.0 = icmp ugt i8* %start, %high
+if.end:
+ %f.0 = icmp ugt ptr %start, %high
call void @use(i1 %f.0)
-
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %f.1 = icmp uge i8* %start.1, %high
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %f.1 = icmp uge ptr %start.1, %high
call void @use(i1 %f.1)
-
- %start.2 = getelementptr inbounds i8, i8* %start, i64 2
- %f.2 = icmp uge i8* %start.2, %high
+ %start.2 = getelementptr inbounds i8, ptr %start, i64 2
+ %f.2 = icmp uge ptr %start.2, %high
call void @use(i1 %f.2)
-
- %start.3 = getelementptr inbounds i8, i8* %start, i64 3
- %f.3 = icmp uge i8* %start.3, %high
+ %start.3 = getelementptr inbounds i8, ptr %start, i64 3
+ %f.3 = icmp uge ptr %start.3, %high
call void @use(i1 %f.3)
-
- %start.4 = getelementptr inbounds i8, i8* %start, i64 4
- %c.4 = icmp uge i8* %start.4, %high
+ %start.4 = getelementptr inbounds i8, ptr %start, i64 4
+ %c.4 = icmp uge ptr %start.4, %high
call void @use(i1 %c.4)
-
- %start.5 = getelementptr inbounds i8, i8* %start, i64 5
- %c.5 = icmp uge i8* %start.5, %high
+ %start.5 = getelementptr inbounds i8, ptr %start, i64 5
+ %c.5 = icmp uge ptr %start.5, %high
call void @use(i1 %c.5)
-
ret void
}
-define void @test.not.uge.uge.nonconst(i8* %start, i8* %low, i8* %high, i8 %off) {
+define void @test.not.uge.uge.nonconst(ptr %start, ptr %low, ptr %high, i8 %off) {
; CHECK-LABEL: @test.not.uge.uge.nonconst(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, i8* [[START:%.*]], i8 [[OFF:%.*]]
-; CHECK-NEXT: [[C_1:%.*]] = icmp uge i8* [[ADD_PTR_I]], [[HIGH:%.*]]
+; CHECK-NEXT: [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i8 [[OFF:%.*]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
; CHECK-NEXT: br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[START_OFF_2:%.*]] = getelementptr inbounds i8, i8* [[START]], i8 [[OFF]]
-; CHECK-NEXT: [[T_0:%.*]] = icmp uge i8* [[START_OFF_2]], [[HIGH]]
+; CHECK-NEXT: [[START_OFF_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i8 [[OFF]]
+; CHECK-NEXT: [[T_0:%.*]] = icmp uge ptr [[START_OFF_2]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[T_0]])
; CHECK-NEXT: ret void
; CHECK: if.end:
-; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, i8* [[START]], i64 1
-; CHECK-NEXT: [[C_0:%.*]] = icmp uge i8* [[START_1]], [[HIGH]]
+; CHECK-NEXT: [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
+; CHECK-NEXT: [[C_0:%.*]] = icmp uge ptr [[START_1]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[C_0]])
-; CHECK-NEXT: [[START_OFF:%.*]] = getelementptr inbounds i8, i8* [[START]], i8 [[OFF]]
-; CHECK-NEXT: [[F_0:%.*]] = icmp uge i8* [[START_OFF]], [[HIGH]]
+; CHECK-NEXT: [[START_OFF:%.*]] = getelementptr inbounds i8, ptr [[START]], i8 [[OFF]]
+; CHECK-NEXT: [[F_0:%.*]] = icmp uge ptr [[START_OFF]], [[HIGH]]
; CHECK-NEXT: call void @use(i1 [[F_0]])
; CHECK-NEXT: ret void
;
entry:
- %add.ptr.i = getelementptr inbounds i8, i8* %start, i8 %off
- %c.1 = icmp uge i8* %add.ptr.i, %high
+ %add.ptr.i = getelementptr inbounds i8, ptr %start, i8 %off
+ %c.1 = icmp uge ptr %add.ptr.i, %high
br i1 %c.1, label %if.then, label %if.end
-if.then: ; preds = %entry
- %start.off.2 = getelementptr inbounds i8, i8* %start, i8 %off
- %t.0 = icmp uge i8* %start.off.2, %high
+if.then:
+ %start.off.2 = getelementptr inbounds i8, ptr %start, i8 %off
+ %t.0 = icmp uge ptr %start.off.2, %high
call void @use(i1 %t.0)
-
ret void
-if.end: ; preds = %entry
- %start.1 = getelementptr inbounds i8, i8* %start, i64 1
- %c.0 = icmp uge i8* %start.1, %high
+if.end:
+ %start.1 = getelementptr inbounds i8, ptr %start, i64 1
+ %c.0 = icmp uge ptr %start.1, %high
call void @use(i1 %c.0)
-
- %start.off = getelementptr inbounds i8, i8* %start, i8 %off
- %f.0 = icmp uge i8* %start.off, %high
+ %start.off = getelementptr inbounds i8, ptr %start, i8 %off
+ %f.0 = icmp uge ptr %start.off, %high
call void @use(i1 %f.0)
-
ret void
}
; Test which requires decomposing GEP %ptr, SHL().
-define void @test.ult.gep.shl(i32* readonly %src, i32* readnone %max, i8 %idx) {
+define void @test.ult.gep.shl(ptr readonly %src, ptr readnone %max, i8 %idx) {
; CHECK-LABEL: @test.ult.gep.shl(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, i32* [[SRC:%.*]], i32 10
-; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp ugt i32* [[ADD_10]], [[MAX:%.*]]
+; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, ptr [[SRC:%.*]], i32 10
+; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp ugt ptr [[ADD_10]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_ADD_10_MAX]], label [[TRAP:%.*]], label [[CHECK_IDX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret void
@@ -529,65 +511,61 @@ define void @test.ult.gep.shl(i32* readonly %src, i32* readnone %max, i8 %idx) {
; CHECK-NEXT: br i1 [[CMP]], label [[CHECK_MAX:%.*]], label [[TRAP]]
; CHECK: check.max:
; CHECK-NEXT: [[IDX_SHL_1:%.*]] = shl nuw i8 [[IDX]], 1
-; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_1]]
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult i32* [[ADD_PTR_SHL_1]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_1]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult ptr [[ADD_PTR_SHL_1]], [[MAX]]
; CHECK-NEXT: call void @use(i1 true)
; CHECK-NEXT: [[IDX_SHL_2:%.*]] = shl nuw i8 [[IDX]], 2
-; CHECK-NEXT: [[ADD_PTR_SHL_2:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_2]]
-; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp ult i32* [[ADD_PTR_SHL_2]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_2:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_2]]
+; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp ult ptr [[ADD_PTR_SHL_2]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_1]])
; CHECK-NEXT: [[IDX_SHL_NOT_NUW:%.*]] = shl i8 [[IDX]], 1
-; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_NOT_NUW]]
-; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp ult i32* [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_NOT_NUW]]
+; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp ult ptr [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_2]])
; CHECK-NEXT: [[IDX_SHL_3:%.*]] = shl nuw i8 [[IDX]], 3
-; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i8 [[IDX_SHL_3]]
-; CHECK-NEXT: [[C_MAX_3:%.*]] = icmp ult i32* [[ADD_PTR_SHL_3]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_3]]
+; CHECK-NEXT: [[C_MAX_3:%.*]] = icmp ult ptr [[ADD_PTR_SHL_3]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_3]])
; CHECK-NEXT: ret void
;
check.0.min:
- %add.10 = getelementptr inbounds i32, i32* %src, i32 10
- %c.add.10.max = icmp ugt i32* %add.10, %max
+ %add.10 = getelementptr inbounds i32, ptr %src, i32 10
+ %c.add.10.max = icmp ugt ptr %add.10, %max
br i1 %c.add.10.max, label %trap, label %check.idx
trap:
ret void
-check.idx: ; preds = %check.0.min
+check.idx:
%cmp = icmp ult i8 %idx, 5
br i1 %cmp, label %check.max, label %trap
-check.max: ; preds = %check.0.min
+check.max:
%idx.shl.1 = shl nuw i8 %idx, 1
- %add.ptr.shl.1 = getelementptr inbounds i32, i32* %src, i8 %idx.shl.1
- %c.max.0 = icmp ult i32* %add.ptr.shl.1, %max
+ %add.ptr.shl.1 = getelementptr inbounds i32, ptr %src, i8 %idx.shl.1
+ %c.max.0 = icmp ult ptr %add.ptr.shl.1, %max
call void @use(i1 %c.max.0)
-
%idx.shl.2 = shl nuw i8 %idx, 2
- %add.ptr.shl.2 = getelementptr inbounds i32, i32* %src, i8 %idx.shl.2
- %c.max.1 = icmp ult i32* %add.ptr.shl.2, %max
+ %add.ptr.shl.2 = getelementptr inbounds i32, ptr %src, i8 %idx.shl.2
+ %c.max.1 = icmp ult ptr %add.ptr.shl.2, %max
call void @use(i1 %c.max.1)
-
%idx.shl.not.nuw = shl i8 %idx, 1
- %add.ptr.shl.not.nuw = getelementptr inbounds i32, i32* %src, i8 %idx.shl.not.nuw
- %c.max.2 = icmp ult i32* %add.ptr.shl.not.nuw, %max
+ %add.ptr.shl.not.nuw = getelementptr inbounds i32, ptr %src, i8 %idx.shl.not.nuw
+ %c.max.2 = icmp ult ptr %add.ptr.shl.not.nuw, %max
call void @use(i1 %c.max.2)
-
%idx.shl.3 = shl nuw i8 %idx, 3
- %add.ptr.shl.3 = getelementptr inbounds i32, i32* %src, i8 %idx.shl.3
- %c.max.3 = icmp ult i32* %add.ptr.shl.3, %max
+ %add.ptr.shl.3 = getelementptr inbounds i32, ptr %src, i8 %idx.shl.3
+ %c.max.3 = icmp ult ptr %add.ptr.shl.3, %max
call void @use(i1 %c.max.3)
-
ret void
}
; Test which requires decomposing GEP %ptr, ZEXT(SHL()).
-define void @test.ult.gep.shl.zext(i32* readonly %src, i32* readnone %max, i32 %idx, i32 %j) {
+define void @test.ult.gep.shl.zext(ptr readonly %src, ptr readnone %max, i32 %idx, i32 %j) {
; CHECK-LABEL: @test.ult.gep.shl.zext(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, i32* [[SRC:%.*]], i32 10
-; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp ugt i32* [[ADD_10]], [[MAX:%.*]]
+; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i32, ptr [[SRC:%.*]], i32 10
+; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp ugt ptr [[ADD_10]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_ADD_10_MAX]], label [[TRAP:%.*]], label [[CHECK_IDX:%.*]]
; CHECK: trap:
; CHECK-NEXT: ret void
@@ -597,61 +575,58 @@ define void @test.ult.gep.shl.zext(i32* readonly %src, i32* readnone %max, i32 %
; CHECK: check.max:
; CHECK-NEXT: [[IDX_SHL:%.*]] = shl nuw i32 [[IDX]], 1
; CHECK-NEXT: [[EXT_1:%.*]] = zext i32 [[IDX_SHL]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[EXT_1]]
-; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult i32* [[ADD_PTR_SHL]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_1]]
+; CHECK-NEXT: [[C_MAX_0:%.*]] = icmp ult ptr [[ADD_PTR_SHL]], [[MAX]]
; CHECK-NEXT: call void @use(i1 true)
; CHECK-NEXT: [[IDX_SHL_NOT_NUW:%.*]] = shl i32 [[IDX]], 1
; CHECK-NEXT: [[EXT_2:%.*]] = zext i32 [[IDX_SHL_NOT_NUW]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[EXT_2]]
-; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp ult i32* [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_2]]
+; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp ult ptr [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_1]])
; CHECK-NEXT: [[IDX_SHL_3:%.*]] = shl nuw i32 [[IDX]], 2
; CHECK-NEXT: [[EXT_3:%.*]] = zext i32 [[IDX_SHL_3]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[EXT_3]]
-; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp ult i32* [[ADD_PTR_SHL_3]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_3:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_3]]
+; CHECK-NEXT: [[C_MAX_2:%.*]] = icmp ult ptr [[ADD_PTR_SHL_3]], [[MAX]]
; CHECK-NEXT: call void @use(i1 [[C_MAX_2]])
; CHECK-NEXT: ret void
;
check.0.min:
- %add.10 = getelementptr inbounds i32, i32* %src, i32 10
- %c.add.10.max = icmp ugt i32* %add.10, %max
+ %add.10 = getelementptr inbounds i32, ptr %src, i32 10
+ %c.add.10.max = icmp ugt ptr %add.10, %max
br i1 %c.add.10.max, label %trap, label %check.idx
trap:
ret void
-check.idx: ; preds = %check.0.min
+check.idx:
%cmp = icmp ult i32 %idx, 5
br i1 %cmp, label %check.max, label %trap
-check.max: ; preds = %check.0.min
+check.max:
%idx.shl = shl nuw i32 %idx, 1
%ext.1 = zext i32 %idx.shl to i64
- %add.ptr.shl = getelementptr inbounds i32, i32* %src, i64 %ext.1
- %c.max.0 = icmp ult i32* %add.ptr.shl, %max
+ %add.ptr.shl = getelementptr inbounds i32, ptr %src, i64 %ext.1
+ %c.max.0 = icmp ult ptr %add.ptr.shl, %max
call void @use(i1 %c.max.0)
-
%idx.shl.not.nuw = shl i32 %idx, 1
%ext.2 = zext i32 %idx.shl.not.nuw to i64
- %add.ptr.shl.not.nuw = getelementptr inbounds i32, i32* %src, i64 %ext.2
- %c.max.1 = icmp ult i32* %add.ptr.shl.not.nuw, %max
+ %add.ptr.shl.not.nuw = getelementptr inbounds i32, ptr %src, i64 %ext.2
+ %c.max.1 = icmp ult ptr %add.ptr.shl.not.nuw, %max
call void @use(i1 %c.max.1)
-
%idx.shl.3 = shl nuw i32 %idx, 2
%ext.3 = zext i32 %idx.shl.3 to i64
- %add.ptr.shl.3 = getelementptr inbounds i32, i32* %src, i64 %ext.3
- %c.max.2 = icmp ult i32* %add.ptr.shl.3, %max
+ %add.ptr.shl.3 = getelementptr inbounds i32, ptr %src, i64 %ext.3
+ %c.max.2 = icmp ult ptr %add.ptr.shl.3, %max
call void @use(i1 %c.max.2)
-
ret void
}
; Make sure non-constant shift amounts are handled correctly.
-define i1 @test.ult.gep.shl.nonconst.zext(i16 %B, i16* readonly %src, i16* readnone %max, i16 %idx, i16 %j) {
+define i1 @test.ult.gep.shl.nonconst.zext(i16 %B, ptr readonly %src, ptr readnone %max, i16 %idx, i16 %j) {
; CHECK-LABEL: @test.ult.gep.shl.nonconst.zext(
; CHECK-NEXT: check.0.min:
-; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i16, i16* [[SRC:%.*]], i16 10
-; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp ugt i16* [[ADD_10]], [[MAX:%.*]]
+; CHECK-NEXT: [[ADD_10:%.*]] = getelementptr inbounds i16, ptr [[SRC:%.*]], i16 10
+; CHECK-NEXT: [[C_ADD_10_MAX:%.*]] = icmp ugt ptr [[ADD_10]], [[MAX:%.*]]
; CHECK-NEXT: br i1 [[C_ADD_10_MAX]], label [[EXIT_1:%.*]], label [[CHECK_IDX:%.*]]
; CHECK: exit.1:
; CHECK-NEXT: ret i1 true
@@ -661,41 +636,40 @@ define i1 @test.ult.gep.shl.nonconst.zext(i16 %B, i16* readonly %src, i16* readn
; CHECK: check.max:
; CHECK-NEXT: [[IDX_SHL:%.*]] = shl nuw i16 [[IDX]], [[B:%.*]]
; CHECK-NEXT: [[EXT:%.*]] = zext i16 [[IDX_SHL]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i16, i16* [[SRC]], i64 [[EXT]]
-; CHECK-NEXT: [[C_MAX:%.*]] = icmp ult i16* [[ADD_PTR_SHL]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i16, ptr [[SRC]], i64 [[EXT]]
+; CHECK-NEXT: [[C_MAX:%.*]] = icmp ult ptr [[ADD_PTR_SHL]], [[MAX]]
; CHECK-NEXT: ret i1 [[C_MAX]]
; CHECK: trap:
; CHECK-NEXT: [[IDX_SHL_1:%.*]] = shl nuw i16 [[IDX]], [[B]]
; CHECK-NEXT: [[EXT_1:%.*]] = zext i16 [[IDX_SHL_1]] to i64
-; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i16, i16* [[SRC]], i64 [[EXT_1]]
-; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp ult i16* [[ADD_PTR_SHL_1]], [[MAX]]
+; CHECK-NEXT: [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i16, ptr [[SRC]], i64 [[EXT_1]]
+; CHECK-NEXT: [[C_MAX_1:%.*]] = icmp ult ptr [[ADD_PTR_SHL_1]], [[MAX]]
; CHECK-NEXT: ret i1 [[C_MAX_1]]
;
check.0.min:
- %add.10 = getelementptr inbounds i16, i16* %src, i16 10
- %c.add.10.max = icmp ugt i16* %add.10, %max
+ %add.10 = getelementptr inbounds i16, ptr %src, i16 10
+ %c.add.10.max = icmp ugt ptr %add.10, %max
br i1 %c.add.10.max, label %exit.1, label %check.idx
exit.1:
ret i1 true
-
-check.idx: ; preds = %check.0.min
+check.idx:
%cmp = icmp ult i16 %idx, 5
br i1 %cmp, label %check.max, label %trap
-check.max: ; preds = %check.idx
+check.max:
%idx.shl = shl nuw i16 %idx, %B
%ext = zext i16 %idx.shl to i64
- %add.ptr.shl = getelementptr inbounds i16, i16* %src, i64 %ext
- %c.max = icmp ult i16* %add.ptr.shl, %max
+ %add.ptr.shl = getelementptr inbounds i16, ptr %src, i64 %ext
+ %c.max = icmp ult ptr %add.ptr.shl, %max
ret i1 %c.max
-trap: ; preds = %check.idx, %check.0.min
+trap:
%idx.shl.1 = shl nuw i16 %idx, %B
%ext.1 = zext i16 %idx.shl.1 to i64
- %add.ptr.shl.1 = getelementptr inbounds i16, i16* %src, i64 %ext.1
- %c.max.1 = icmp ult i16* %add.ptr.shl.1, %max
+ %add.ptr.shl.1 = getelementptr inbounds i16, ptr %src, i64 %ext.1
+ %c.max.1 = icmp ult ptr %add.ptr.shl.1, %max
ret i1 %c.max.1
}
diff --git a/llvm/test/Transforms/ConstraintElimination/invoke.ll b/llvm/test/Transforms/ConstraintElimination/invoke.ll
index 30636bcddd9c9..4bbc3a9fe60a0 100644
--- a/llvm/test/Transforms/ConstraintElimination/invoke.ll
+++ b/llvm/test/Transforms/ConstraintElimination/invoke.ll
@@ -3,9 +3,9 @@
declare void @may_unwind()
-declare i32 @__gxx_personality_v0(...);
+declare i32 @__gxx_personality_v0(...)
-define i1 @test_invoke_in_block_with_assume(i32 %x) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define i1 @test_invoke_in_block_with_assume(i32 %x) personality ptr @__gxx_personality_v0 {
; CHECK-LABEL: @test_invoke_in_block_with_assume(
; CHECK-NEXT: entry:
; CHECK-NEXT: call void @may_unwind()
@@ -19,8 +19,8 @@ define i1 @test_invoke_in_block_with_assume(i32 %x) personality i8* bitcast (i32
; CHECK-NEXT: [[RES_1:%.*]] = xor i1 true, [[C_2]]
; CHECK-NEXT: ret i1 [[RES_1]]
; CHECK: lpad:
-; CHECK-NEXT: [[LP:%.*]] = landingpad { i8*, i32 }
-; CHECK-NEXT: filter [0 x i8*] zeroinitializer
+; CHECK-NEXT: [[LP:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT: filter [0 x ptr] zeroinitializer
; CHECK-NEXT: [[T_2:%.*]] = icmp ult i32 [[X]], 10
; CHECK-NEXT: [[C_3:%.*]] = icmp ult i32 [[X]], 9
; CHECK-NEXT: [[RES_2:%.*]] = xor i1 true, [[C_3]]
@@ -30,7 +30,8 @@ entry:
call void @may_unwind()
%c.1 = icmp ult i32 %x, 10
call void @llvm.assume(i1 %c.1)
- invoke void @may_unwind() to label %cont unwind label %lpad
+ invoke void @may_unwind()
+ to label %cont unwind label %lpad
cont:
%t.1 = icmp ult i32 %x, 10
@@ -39,8 +40,8 @@ cont:
ret i1 %res.1
lpad:
- %lp = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %lp = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
%t.2 = icmp ult i32 %x, 10
%c.3 = icmp ult i32 %x, 9
%res.2 = xor i1 %t.2, %c.3
diff --git a/llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll b/llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll
index 9f759c97e01e8..be04ded7535b4 100644
--- a/llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll
+++ b/llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll
@@ -123,46 +123,46 @@ else:
ret i1 false
}
-define i1 @gep_decomp_i80(i8* %a) {
+define i1 @gep_decomp_i80(ptr %a) {
; CHECK-LABEL: @gep_decomp_i80(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i80 1973801615886922022913
-; CHECK-NEXT: [[C:%.*]] = icmp eq i8* [[GEP]], null
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i80 1973801615886922022913
+; CHECK-NEXT: [[C:%.*]] = icmp eq ptr [[GEP]], null
; CHECK-NEXT: br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
-; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, i8* [[A]], i80 1973801615886922022913
-; CHECK-NEXT: [[C_1:%.*]] = icmp eq i8* [[GEP_1]], null
+; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i80 1973801615886922022913
+; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[GEP_1]], null
; CHECK-NEXT: ret i1 [[C_1]]
; CHECK: else:
; CHECK-NEXT: ret i1 false
;
entry:
- %gep = getelementptr inbounds i8, i8* %a, i80 1973801615886922022913
- %c = icmp eq i8* %gep, null
+ %gep = getelementptr inbounds i8, ptr %a, i80 1973801615886922022913
+ %c = icmp eq ptr %gep, null
br i1 %c, label %then, label %else
then:
- %gep.1 = getelementptr inbounds i8, i8* %a, i80 1973801615886922022913
- %c.1 = icmp eq i8* %gep.1, null
+ %gep.1 = getelementptr inbounds i8, ptr %a, i80 1973801615886922022913
+ %c.1 = icmp eq ptr %gep.1, null
ret i1 %c.1
else:
ret i1 false
}
-define i1 @gep_zext_shl_decomp_i80(i8* %a, i80 %v) {
+define i1 @gep_zext_shl_decomp_i80(ptr %a, i80 %v) {
; CHECK-LABEL: @gep_zext_shl_decomp_i80(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[SHL:%.*]] = shl nuw i80 [[V:%.*]], 1973801615886922022913
; CHECK-NEXT: [[EXT:%.*]] = zext i80 [[SHL]] to i128
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i128 [[EXT]]
-; CHECK-NEXT: [[C:%.*]] = icmp eq i8* [[GEP]], null
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i128 [[EXT]]
+; CHECK-NEXT: [[C:%.*]] = icmp eq ptr [[GEP]], null
; CHECK-NEXT: br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
; CHECK-NEXT: [[SHL_1:%.*]] = shl nuw i80 [[V]], 1973801615886922022913
; CHECK-NEXT: [[EXT_1:%.*]] = zext i80 [[SHL_1]] to i128
-; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, i8* [[A]], i128 [[EXT_1]]
-; CHECK-NEXT: [[C_1:%.*]] = icmp eq i8* [[GEP_1]], null
+; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i128 [[EXT_1]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[GEP_1]], null
; CHECK-NEXT: ret i1 [[C_1]]
; CHECK: else:
; CHECK-NEXT: ret i1 false
@@ -170,34 +170,34 @@ define i1 @gep_zext_shl_decomp_i80(i8* %a, i80 %v) {
entry:
%shl = shl nuw i80 %v, 1973801615886922022913
%ext = zext i80 %shl to i128
- %gep = getelementptr inbounds i8, i8* %a, i128 %ext
- %c = icmp eq i8* %gep, null
+ %gep = getelementptr inbounds i8, ptr %a, i128 %ext
+ %c = icmp eq ptr %gep, null
br i1 %c, label %then, label %else
then:
%shl.1 = shl nuw i80 %v, 1973801615886922022913
%ext.1 = zext i80 %shl.1 to i128
- %gep.1 = getelementptr inbounds i8, i8* %a, i128 %ext.1
- %c.1 = icmp eq i8* %gep.1, null
+ %gep.1 = getelementptr inbounds i8, ptr %a, i128 %ext.1
+ %c.1 = icmp eq ptr %gep.1, null
ret i1 %c.1
else:
ret i1 false
}
-define i1 @gep_zext_add_decomp_i80(i8* %a, i80 %v) {
+define i1 @gep_zext_add_decomp_i80(ptr %a, i80 %v) {
; CHECK-LABEL: @gep_zext_add_decomp_i80(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[ADD:%.*]] = add nsw i80 [[V:%.*]], 1973801615886922022913
; CHECK-NEXT: [[EXT:%.*]] = zext i80 [[ADD]] to i128
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i128 [[EXT]]
-; CHECK-NEXT: [[C:%.*]] = icmp eq i8* [[GEP]], null
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i128 [[EXT]]
+; CHECK-NEXT: [[C:%.*]] = icmp eq ptr [[GEP]], null
; CHECK-NEXT: br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
; CHECK-NEXT: [[ADD_1:%.*]] = add nsw i80 [[V]], 1973801615886922022913
; CHECK-NEXT: [[EXT_1:%.*]] = zext i80 [[ADD_1]] to i128
-; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, i8* [[A]], i128 [[EXT_1]]
-; CHECK-NEXT: [[C_1:%.*]] = icmp eq i8* [[GEP_1]], null
+; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i128 [[EXT_1]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[GEP_1]], null
; CHECK-NEXT: ret i1 [[C_1]]
; CHECK: else:
; CHECK-NEXT: ret i1 false
@@ -205,77 +205,77 @@ define i1 @gep_zext_add_decomp_i80(i8* %a, i80 %v) {
entry:
%add = add nsw i80 %v, 1973801615886922022913
%ext = zext i80 %add to i128
- %gep = getelementptr inbounds i8, i8* %a, i128 %ext
- %c = icmp eq i8* %gep, null
+ %gep = getelementptr inbounds i8, ptr %a, i128 %ext
+ %c = icmp eq ptr %gep, null
br i1 %c, label %then, label %else
then:
%add.1 = add nsw i80 %v, 1973801615886922022913
%ext.1 = zext i80 %add.1 to i128
- %gep.1 = getelementptr inbounds i8, i8* %a, i128 %ext.1
- %c.1 = icmp eq i8* %gep.1, null
+ %gep.1 = getelementptr inbounds i8, ptr %a, i128 %ext.1
+ %c.1 = icmp eq ptr %gep.1, null
ret i1 %c.1
else:
ret i1 false
}
-define i1 @gep_shl_decomp_i80(i8* %a, i80 %v) {
+define i1 @gep_shl_decomp_i80(ptr %a, i80 %v) {
; CHECK-LABEL: @gep_shl_decomp_i80(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[SHL:%.*]] = shl nuw i80 [[V:%.*]], 1973801615886922022913
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i80 [[SHL]]
-; CHECK-NEXT: [[C:%.*]] = icmp eq i8* [[GEP]], null
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i80 [[SHL]]
+; CHECK-NEXT: [[C:%.*]] = icmp eq ptr [[GEP]], null
; CHECK-NEXT: br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
; CHECK-NEXT: [[SHL_1:%.*]] = shl nuw i80 [[V]], 1973801615886922022913
-; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, i8* [[A]], i80 [[SHL_1]]
-; CHECK-NEXT: [[C_1:%.*]] = icmp eq i8* [[GEP_1]], null
+; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i80 [[SHL_1]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[GEP_1]], null
; CHECK-NEXT: ret i1 [[C_1]]
; CHECK: else:
; CHECK-NEXT: ret i1 false
;
entry:
%shl = shl nuw i80 %v, 1973801615886922022913
- %gep = getelementptr inbounds i8, i8* %a, i80 %shl
- %c = icmp eq i8* %gep, null
+ %gep = getelementptr inbounds i8, ptr %a, i80 %shl
+ %c = icmp eq ptr %gep, null
br i1 %c, label %then, label %else
then:
%shl.1 = shl nuw i80 %v, 1973801615886922022913
- %gep.1 = getelementptr inbounds i8, i8* %a, i80 %shl.1
- %c.1 = icmp eq i8* %gep.1, null
+ %gep.1 = getelementptr inbounds i8, ptr %a, i80 %shl.1
+ %c.1 = icmp eq ptr %gep.1, null
ret i1 %c.1
else:
ret i1 false
}
-define i1 @gep_add_decomp_i80(i8* %a, i80 %v) {
+define i1 @gep_add_decomp_i80(ptr %a, i80 %v) {
; CHECK-LABEL: @gep_add_decomp_i80(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[ADD:%.*]] = add nsw i80 [[V:%.*]], 1973801615886922022913
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i80 [[ADD]]
-; CHECK-NEXT: [[C:%.*]] = icmp eq i8* [[GEP]], null
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i80 [[ADD]]
+; CHECK-NEXT: [[C:%.*]] = icmp eq ptr [[GEP]], null
; CHECK-NEXT: br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
; CHECK-NEXT: [[ADD_1:%.*]] = add nsw i80 [[V]], 1973801615886922022913
-; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, i8* [[A]], i80 [[ADD_1]]
-; CHECK-NEXT: [[C_1:%.*]] = icmp eq i8* [[GEP_1]], null
+; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i80 [[ADD_1]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[GEP_1]], null
; CHECK-NEXT: ret i1 [[C_1]]
; CHECK: else:
; CHECK-NEXT: ret i1 false
;
entry:
%add = add nsw i80 %v, 1973801615886922022913
- %gep = getelementptr inbounds i8, i8* %a, i80 %add
- %c = icmp eq i8* %gep, null
+ %gep = getelementptr inbounds i8, ptr %a, i80 %add
+ %c = icmp eq ptr %gep, null
br i1 %c, label %then, label %else
then:
%add.1 = add nsw i80 %v, 1973801615886922022913
- %gep.1 = getelementptr inbounds i8, i8* %a, i80 %add.1
- %c.1 = icmp eq i8* %gep.1, null
+ %gep.1 = getelementptr inbounds i8, ptr %a, i80 %add.1
+ %c.1 = icmp eq ptr %gep.1, null
ret i1 %c.1
else:
diff --git a/llvm/test/Transforms/ConstraintElimination/large-system-growth.ll b/llvm/test/Transforms/ConstraintElimination/large-system-growth.ll
index 8ea882426ee8f..d91406d74b80e 100644
--- a/llvm/test/Transforms/ConstraintElimination/large-system-growth.ll
+++ b/llvm/test/Transforms/ConstraintElimination/large-system-growth.ll
@@ -3,82 +3,82 @@
; The system for the function below grows quite large. Check to make sure
; we can handle that scenario.
-define void @test(i64 %x, i8* %y, i8* %z, i8* %w) {
+define void @test(i64 %x, ptr %y, ptr %z, ptr %w) {
; CHECK-LABEL: @test(
-; CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds i8, i8* [[Y:%.*]], i64 [[X:%.*]]
-; CHECK-NEXT: [[TMP26:%.*]] = icmp ult i8* [[TMP22]], [[Z:%.*]]
+; CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds i8, ptr [[Y:%.*]], i64 [[X:%.*]]
+; CHECK-NEXT: [[TMP26:%.*]] = icmp ult ptr [[TMP22]], [[Z:%.*]]
; CHECK-NEXT: br i1 [[TMP26]], label [[BB28:%.*]], label [[EARLY_EXIT:%.*]]
; CHECK: early.exit:
; CHECK-NEXT: unreachable
; CHECK: bb28:
-; CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds i8, i8* [[Y]], i64 [[X]]
-; CHECK-NEXT: [[TMP30:%.*]] = icmp ult i8* [[TMP29]], [[Z]]
+; CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds i8, ptr [[Y]], i64 [[X]]
+; CHECK-NEXT: [[TMP30:%.*]] = icmp ult ptr [[TMP29]], [[Z]]
; CHECK-NEXT: br i1 [[TMP30]], label [[EARLY_EXIT]], label [[BB32:%.*]]
; CHECK: bb32:
-; CHECK-NEXT: [[TMP33:%.*]] = icmp ult i8* [[TMP29]], [[Z]]
+; CHECK-NEXT: [[TMP33:%.*]] = icmp ult ptr [[TMP29]], [[Z]]
; CHECK-NEXT: br i1 [[TMP33]], label [[BB35:%.*]], label [[EARLY_EXIT]]
; CHECK: bb35:
-; CHECK-NEXT: [[TMP36:%.*]] = icmp ult i8* [[Y]], [[Z]]
+; CHECK-NEXT: [[TMP36:%.*]] = icmp ult ptr [[Y]], [[Z]]
; CHECK-NEXT: br i1 [[TMP36]], label [[EARLY_EXIT]], label [[BB38:%.*]]
; CHECK: bb38:
-; CHECK-NEXT: [[TMP41:%.*]] = icmp ult i8* [[Y]], [[Z]]
+; CHECK-NEXT: [[TMP41:%.*]] = icmp ult ptr [[Y]], [[Z]]
; CHECK-NEXT: br i1 false, label [[EARLY_EXIT]], label [[BB43:%.*]]
; CHECK: bb43:
-; CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds i8, i8* [[W:%.*]], i64 [[X]]
-; CHECK-NEXT: [[TMP48:%.*]] = icmp ult i8* [[TMP47]], [[Y]]
+; CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds i8, ptr [[W:%.*]], i64 [[X]]
+; CHECK-NEXT: [[TMP48:%.*]] = icmp ult ptr [[TMP47]], [[Y]]
; CHECK-NEXT: br i1 [[TMP48]], label [[EARLY_EXIT]], label [[BB50:%.*]]
; CHECK: bb50:
-; CHECK-NEXT: [[TMP52:%.*]] = getelementptr inbounds i8, i8* [[W]], i64 [[X]]
-; CHECK-NEXT: [[TMP53:%.*]] = icmp ult i8* [[TMP52]], [[Y]]
+; CHECK-NEXT: [[TMP52:%.*]] = getelementptr inbounds i8, ptr [[W]], i64 [[X]]
+; CHECK-NEXT: [[TMP53:%.*]] = icmp ult ptr [[TMP52]], [[Y]]
; CHECK-NEXT: br i1 [[TMP53]], label [[EARLY_EXIT]], label [[BB55:%.*]]
; CHECK: bb55:
-; CHECK-NEXT: [[TMP57:%.*]] = icmp ult i8* [[W]], [[Y]]
+; CHECK-NEXT: [[TMP57:%.*]] = icmp ult ptr [[W]], [[Y]]
; CHECK-NEXT: br i1 [[TMP57]], label [[BB59:%.*]], label [[EARLY_EXIT]]
; CHECK: bb59:
-; CHECK-NEXT: [[TMP60:%.*]] = icmp ult i8* [[W]], [[Y]]
+; CHECK-NEXT: [[TMP60:%.*]] = icmp ult ptr [[W]], [[Y]]
; CHECK-NEXT: call void @use(i1 true)
; CHECK-NEXT: ret void
;
- %tmp22 = getelementptr inbounds i8, i8* %y, i64 %x
- %tmp26 = icmp ult i8* %tmp22, %z
+ %tmp22 = getelementptr inbounds i8, ptr %y, i64 %x
+ %tmp26 = icmp ult ptr %tmp22, %z
br i1 %tmp26, label %bb28, label %early.exit
early.exit:
unreachable
bb28:
- %tmp29 = getelementptr inbounds i8, i8* %y, i64 %x
- %tmp30 = icmp ult i8* %tmp29, %z
+ %tmp29 = getelementptr inbounds i8, ptr %y, i64 %x
+ %tmp30 = icmp ult ptr %tmp29, %z
br i1 %tmp30, label %early.exit, label %bb32
bb32:
- %tmp33 = icmp ult i8* %tmp29, %z
+ %tmp33 = icmp ult ptr %tmp29, %z
br i1 %tmp33, label %bb35, label %early.exit
bb35:
- %tmp36 = icmp ult i8* %y, %z
+ %tmp36 = icmp ult ptr %y, %z
br i1 %tmp36, label %early.exit, label %bb38
bb38:
- %tmp41 = icmp ult i8* %y, %z
+ %tmp41 = icmp ult ptr %y, %z
br i1 %tmp41, label %early.exit, label %bb43
bb43:
- %tmp47 = getelementptr inbounds i8, i8* %w, i64 %x
- %tmp48 = icmp ult i8* %tmp47, %y
+ %tmp47 = getelementptr inbounds i8, ptr %w, i64 %x
+ %tmp48 = icmp ult ptr %tmp47, %y
br i1 %tmp48, label %early.exit, label %bb50
bb50:
- %tmp52 = getelementptr inbounds i8, i8* %w, i64 %x
- %tmp53 = icmp ult i8* %tmp52, %y
+ %tmp52 = getelementptr inbounds i8, ptr %w, i64 %x
+ %tmp53 = icmp ult ptr %tmp52, %y
br i1 %tmp53, label %early.exit, label %bb55
bb55:
- %tmp57 = icmp ult i8* %w, %y
+ %tmp57 = icmp ult ptr %w, %y
br i1 %tmp57, label %bb59, label %early.exit
bb59:
- %tmp60 = icmp ult i8* %w, %y
+ %tmp60 = icmp ult ptr %w, %y
call void @use(i1 %tmp60)
ret void
}
diff --git a/llvm/test/Transforms/ConstraintElimination/loops-bottom-tested-pointer-cmps.ll b/llvm/test/Transforms/ConstraintElimination/loops-bottom-tested-pointer-cmps.ll
index d1e7d6dc8a972..17a54b6ecbe2e 100644
--- a/llvm/test/Transforms/ConstraintElimination/loops-bottom-tested-pointer-cmps.ll
+++ b/llvm/test/Transforms/ConstraintElimination/loops-bottom-tested-pointer-cmps.ll
@@ -2,15 +2,16 @@
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
declare void @use(i1)
-define void @checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8 %n) {
+
+define void @checks_in_loops_removable(ptr %ptr, ptr %lower, ptr %upper, i8 %n) {
; CHECK-LABEL: @checks_in_loops_removable(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult i8* [[PTR:%.*]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult ptr [[PTR:%.*]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_LOWER]], label [[TRAP:%.*]], label [[PRE_1:%.*]]
; CHECK: pre.1:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i8 [[N:%.*]] to i16
-; CHECK-NEXT: [[PTR_N:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IDX_EXT]]
-; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult i8* [[PTR_N]], [[UPPER:%.*]]
+; CHECK-NEXT: [[PTR_N:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IDX_EXT]]
+; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult ptr [[PTR_N]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_N_UPPER]], label [[PRE_2:%.*]], label [[TRAP]]
; CHECK: pre.2:
; CHECK-NEXT: [[CMP_N_NOT_ZERO:%.*]] = icmp eq i8 [[N]], 0
@@ -19,13 +20,13 @@ define void @checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8 %n)
; CHECK-NEXT: ret void
; CHECK: loop.header:
; CHECK-NEXT: [[IV:%.*]] = phi i16 [ 0, [[PRE_2]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
-; CHECK-NEXT: [[PTR_IV:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV]]
-; CHECK-NEXT: [[CMP_PTR_IV_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[PTR_IV]]
-; CHECK-NEXT: [[CMP_PTR_IV_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[PTR_IV]]
+; CHECK-NEXT: [[PTR_IV:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV]]
+; CHECK-NEXT: [[CMP_PTR_IV_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[PTR_IV]]
+; CHECK-NEXT: [[CMP_PTR_IV_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[PTR_IV]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP_PTR_IV_LOWER]], [[CMP_PTR_IV_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: store i8 0, i8* [[PTR_IV]], align 4
+; CHECK-NEXT: store i8 0, ptr [[PTR_IV]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i16 [[IV_NEXT]], [[IDX_EXT]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP_HEADER]], label [[EXIT]]
@@ -33,13 +34,13 @@ define void @checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8 %n)
; CHECK-NEXT: ret void
;
entry:
- %cmp.ptr.lower = icmp ult i8* %ptr, %lower
+ %cmp.ptr.lower = icmp ult ptr %ptr, %lower
br i1 %cmp.ptr.lower, label %trap, label %pre.1
pre.1:
%idx.ext = zext i8 %n to i16
- %ptr.n = getelementptr inbounds i8, i8* %ptr, i16 %idx.ext
- %cmp.ptr.n.upper = icmp ult i8* %ptr.n, %upper
+ %ptr.n = getelementptr inbounds i8, ptr %ptr, i16 %idx.ext
+ %cmp.ptr.n.upper = icmp ult ptr %ptr.n, %upper
br i1 %cmp.ptr.n.upper, label %pre.2, label %trap
pre.2:
@@ -51,14 +52,14 @@ trap:
loop.header:
%iv = phi i16 [ 0, %pre.2 ], [ %iv.next, %loop.latch ]
- %ptr.iv = getelementptr inbounds i8, i8* %ptr, i16 %iv
- %cmp.ptr.iv.lower = icmp ugt i8* %lower, %ptr.iv
- %cmp.ptr.iv.upper = icmp ule i8* %upper, %ptr.iv
+ %ptr.iv = getelementptr inbounds i8, ptr %ptr, i16 %iv
+ %cmp.ptr.iv.lower = icmp ugt ptr %lower, %ptr.iv
+ %cmp.ptr.iv.upper = icmp ule ptr %upper, %ptr.iv
%or = or i1 %cmp.ptr.iv.lower, %cmp.ptr.iv.upper
br i1 %or, label %trap, label %loop.latch
loop.latch:
- store i8 0, i8* %ptr.iv, align 4
+ store i8 0, ptr %ptr.iv, align 4
%iv.next = add nuw nsw i16 %iv, 1
%exitcond = icmp ne i16 %iv.next, %idx.ext
br i1 %exitcond, label %loop.header, label %exit
@@ -67,15 +68,15 @@ exit:
ret void
}
-define void @some_checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8 %n) {
+define void @some_checks_in_loops_removable(ptr %ptr, ptr %lower, ptr %upper, i8 %n) {
; CHECK-LABEL: @some_checks_in_loops_removable(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult i8* [[PTR:%.*]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult ptr [[PTR:%.*]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_LOWER]], label [[TRAP:%.*]], label [[PRE_1:%.*]]
; CHECK: pre.1:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i8 [[N:%.*]] to i16
-; CHECK-NEXT: [[PTR_N:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IDX_EXT]]
-; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult i8* [[PTR_N]], [[UPPER:%.*]]
+; CHECK-NEXT: [[PTR_N:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IDX_EXT]]
+; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult ptr [[PTR_N]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_N_UPPER]], label [[PRE_2:%.*]], label [[TRAP]]
; CHECK: pre.2:
; CHECK-NEXT: [[CMP_N_NOT_ZERO:%.*]] = icmp eq i8 [[N]], 0
@@ -84,20 +85,20 @@ define void @some_checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8
; CHECK-NEXT: ret void
; CHECK: loop.header:
; CHECK-NEXT: [[IV:%.*]] = phi i16 [ 0, [[PRE_2]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
-; CHECK-NEXT: [[PTR_IV:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV]]
-; CHECK-NEXT: [[CMP_PTR_IV_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[PTR_IV]]
-; CHECK-NEXT: [[CMP_PTR_IV_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[PTR_IV]]
+; CHECK-NEXT: [[PTR_IV:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV]]
+; CHECK-NEXT: [[CMP_PTR_IV_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[PTR_IV]]
+; CHECK-NEXT: [[CMP_PTR_IV_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[PTR_IV]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP_PTR_IV_LOWER]], [[CMP_PTR_IV_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[LOOP_BODY:%.*]]
; CHECK: loop.body:
; CHECK-NEXT: [[IV_1:%.*]] = add nuw nsw i16 [[IV]], 1
-; CHECK-NEXT: [[PTR_IV_1:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV_1]]
-; CHECK-NEXT: [[CMP_PTR_IV_1_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[PTR_IV_1]]
-; CHECK-NEXT: [[CMP_PTR_IV_1_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[PTR_IV_1]]
+; CHECK-NEXT: [[PTR_IV_1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV_1]]
+; CHECK-NEXT: [[CMP_PTR_IV_1_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[PTR_IV_1]]
+; CHECK-NEXT: [[CMP_PTR_IV_1_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[PTR_IV_1]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_PTR_IV_1_LOWER]], [[CMP_PTR_IV_1_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: store i8 0, i8* [[PTR_IV]], align 4
+; CHECK-NEXT: store i8 0, ptr [[PTR_IV]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i16 [[IV_NEXT]], [[IDX_EXT]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP_HEADER]], label [[EXIT]]
@@ -105,13 +106,13 @@ define void @some_checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8
; CHECK-NEXT: ret void
;
entry:
- %cmp.ptr.lower = icmp ult i8* %ptr, %lower
+ %cmp.ptr.lower = icmp ult ptr %ptr, %lower
br i1 %cmp.ptr.lower, label %trap, label %pre.1
pre.1:
%idx.ext = zext i8 %n to i16
- %ptr.n = getelementptr inbounds i8, i8* %ptr, i16 %idx.ext
- %cmp.ptr.n.upper = icmp ult i8* %ptr.n, %upper
+ %ptr.n = getelementptr inbounds i8, ptr %ptr, i16 %idx.ext
+ %cmp.ptr.n.upper = icmp ult ptr %ptr.n, %upper
br i1 %cmp.ptr.n.upper, label %pre.2, label %trap
pre.2:
@@ -123,22 +124,22 @@ trap:
loop.header:
%iv = phi i16 [ 0, %pre.2 ], [ %iv.next, %loop.latch ]
- %ptr.iv = getelementptr inbounds i8, i8* %ptr, i16 %iv
- %cmp.ptr.iv.lower = icmp ugt i8* %lower, %ptr.iv
- %cmp.ptr.iv.upper = icmp ule i8* %upper, %ptr.iv
+ %ptr.iv = getelementptr inbounds i8, ptr %ptr, i16 %iv
+ %cmp.ptr.iv.lower = icmp ugt ptr %lower, %ptr.iv
+ %cmp.ptr.iv.upper = icmp ule ptr %upper, %ptr.iv
%or = or i1 %cmp.ptr.iv.lower, %cmp.ptr.iv.upper
br i1 %or, label %trap, label %loop.body
loop.body:
%iv.1 = add nuw nsw i16 %iv, 1
- %ptr.iv.1 = getelementptr inbounds i8, i8* %ptr, i16 %iv.1
- %cmp.ptr.iv.1.lower = icmp ugt i8* %lower, %ptr.iv.1
- %cmp.ptr.iv.1.upper = icmp ule i8* %upper, %ptr.iv.1
+ %ptr.iv.1 = getelementptr inbounds i8, ptr %ptr, i16 %iv.1
+ %cmp.ptr.iv.1.lower = icmp ugt ptr %lower, %ptr.iv.1
+ %cmp.ptr.iv.1.upper = icmp ule ptr %upper, %ptr.iv.1
%or.1 = or i1 %cmp.ptr.iv.1.lower, %cmp.ptr.iv.1.upper
br i1 %or, label %trap, label %loop.latch
loop.latch:
- store i8 0, i8* %ptr.iv, align 4
+ store i8 0, ptr %ptr.iv, align 4
%iv.next = add nuw nsw i16 %iv, 1
%exitcond = icmp ne i16 %iv.next, %idx.ext
br i1 %exitcond, label %loop.header, label %exit
@@ -147,36 +148,35 @@ exit:
ret void
}
-
; N might be zero, cannot remove upper checks.
-define void @no_checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8 %n) {
+define void @no_checks_in_loops_removable(ptr %ptr, ptr %lower, ptr %upper, i8 %n) {
; CHECK-LABEL: @no_checks_in_loops_removable(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult i8* [[PTR:%.*]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult ptr [[PTR:%.*]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_LOWER]], label [[TRAP:%.*]], label [[PRE_1:%.*]]
; CHECK: pre.1:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i8 [[N:%.*]] to i16
-; CHECK-NEXT: [[PTR_N:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IDX_EXT]]
-; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult i8* [[PTR_N]], [[UPPER:%.*]]
+; CHECK-NEXT: [[PTR_N:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IDX_EXT]]
+; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult ptr [[PTR_N]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_N_UPPER]], label [[LOOP_HEADER:%.*]], label [[TRAP]]
; CHECK: trap:
; CHECK-NEXT: ret void
; CHECK: loop.header:
; CHECK-NEXT: [[IV:%.*]] = phi i16 [ 0, [[PRE_1]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
-; CHECK-NEXT: [[PTR_IV:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV]]
-; CHECK-NEXT: [[CMP_PTR_IV_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[PTR_IV]]
-; CHECK-NEXT: [[CMP_PTR_IV_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[PTR_IV]]
+; CHECK-NEXT: [[PTR_IV:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV]]
+; CHECK-NEXT: [[CMP_PTR_IV_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[PTR_IV]]
+; CHECK-NEXT: [[CMP_PTR_IV_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[PTR_IV]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP_PTR_IV_LOWER]], [[CMP_PTR_IV_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[LOOP_BODY:%.*]]
; CHECK: loop.body:
; CHECK-NEXT: [[IV_1:%.*]] = add nuw nsw i16 [[IV]], 1
-; CHECK-NEXT: [[PTR_IV_1:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV_1]]
-; CHECK-NEXT: [[CMP_PTR_IV_1_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[PTR_IV_1]]
-; CHECK-NEXT: [[CMP_PTR_IV_1_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[PTR_IV_1]]
+; CHECK-NEXT: [[PTR_IV_1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV_1]]
+; CHECK-NEXT: [[CMP_PTR_IV_1_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[PTR_IV_1]]
+; CHECK-NEXT: [[CMP_PTR_IV_1_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[PTR_IV_1]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_PTR_IV_1_LOWER]], [[CMP_PTR_IV_1_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: store i8 0, i8* [[PTR_IV]], align 4
+; CHECK-NEXT: store i8 0, ptr [[PTR_IV]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i16 [[IV_NEXT]], [[IDX_EXT]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP_HEADER]], label [[EXIT:%.*]]
@@ -184,13 +184,13 @@ define void @no_checks_in_loops_removable(i8* %ptr, i8* %lower, i8* %upper, i8 %
; CHECK-NEXT: ret void
;
entry:
- %cmp.ptr.lower = icmp ult i8* %ptr, %lower
+ %cmp.ptr.lower = icmp ult ptr %ptr, %lower
br i1 %cmp.ptr.lower, label %trap, label %pre.1
pre.1:
%idx.ext = zext i8 %n to i16
- %ptr.n = getelementptr inbounds i8, i8* %ptr, i16 %idx.ext
- %cmp.ptr.n.upper = icmp ult i8* %ptr.n, %upper
+ %ptr.n = getelementptr inbounds i8, ptr %ptr, i16 %idx.ext
+ %cmp.ptr.n.upper = icmp ult ptr %ptr.n, %upper
br i1 %cmp.ptr.n.upper, label %loop.header, label %trap
trap:
@@ -198,22 +198,22 @@ trap:
loop.header:
%iv = phi i16 [ 0, %pre.1 ], [ %iv.next, %loop.latch ]
- %ptr.iv = getelementptr inbounds i8, i8* %ptr, i16 %iv
- %cmp.ptr.iv.lower = icmp ugt i8* %lower, %ptr.iv
- %cmp.ptr.iv.upper = icmp ule i8* %upper, %ptr.iv
+ %ptr.iv = getelementptr inbounds i8, ptr %ptr, i16 %iv
+ %cmp.ptr.iv.lower = icmp ugt ptr %lower, %ptr.iv
+ %cmp.ptr.iv.upper = icmp ule ptr %upper, %ptr.iv
%or = or i1 %cmp.ptr.iv.lower, %cmp.ptr.iv.upper
br i1 %or, label %trap, label %loop.body
loop.body:
%iv.1 = add nuw nsw i16 %iv, 1
- %ptr.iv.1 = getelementptr inbounds i8, i8* %ptr, i16 %iv.1
- %cmp.ptr.iv.1.lower = icmp ugt i8* %lower, %ptr.iv.1
- %cmp.ptr.iv.1.upper = icmp ule i8* %upper, %ptr.iv.1
+ %ptr.iv.1 = getelementptr inbounds i8, ptr %ptr, i16 %iv.1
+ %cmp.ptr.iv.1.lower = icmp ugt ptr %lower, %ptr.iv.1
+ %cmp.ptr.iv.1.upper = icmp ule ptr %upper, %ptr.iv.1
%or.1 = or i1 %cmp.ptr.iv.1.lower, %cmp.ptr.iv.1.upper
br i1 %or, label %trap, label %loop.latch
loop.latch:
- store i8 0, i8* %ptr.iv, align 4
+ store i8 0, ptr %ptr.iv, align 4
%iv.next = add nuw nsw i16 %iv, 1
%exitcond = icmp ne i16 %iv.next, %idx.ext
br i1 %exitcond, label %loop.header, label %exit
diff --git a/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll b/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll
index ba15c6009d099..1c4ff692e200e 100644
--- a/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll
+++ b/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll
@@ -3,12 +3,12 @@
declare void @use(i1)
-define void @test1(i8* %src, i8* noundef %lower, i8* noundef %upper, i8 %N) {
+define void @test1(ptr %src, ptr noundef %lower, ptr noundef %upper, i8 %N) {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
; CHECK-NEXT: [[OR_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: br i1 [[OR_0]], label [[TRAP_BB:%.*]], label [[LOOP_HEADER:%.*]]
; CHECK: trap.bb:
@@ -18,41 +18,41 @@ define void @test1(i8* %src, i8* noundef %lower, i8* noundef %upper, i8 %N) {
; CHECK-NEXT: [[EC:%.*]] = icmp uge i8 [[IV]], [[N]]
; CHECK-NEXT: br i1 [[EC]], label [[EXIT:%.*]], label [[LOOP_BODY:%.*]]
; CHECK: loop.body:
-; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[IV]]
-; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult i8* [[SRC_IV]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge i8* [[SRC_IV]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[IV]]
+; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult ptr [[SRC_IV]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge ptr [[SRC_IV]], [[UPPER]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_START]], [[CMP_IV_END]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP_BB]], label [[LOOP_BODY_1:%.*]]
; CHECK: loop.body.1:
-; CHECK-NEXT: [[PTR_SRC_IV:%.*]] = bitcast i8* [[SRC_IV]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[PTR_SRC_IV]], align 4
+; CHECK-NEXT: [[PTR_SRC_IV:%.*]] = bitcast ptr [[SRC_IV]] to ptr
+; CHECK-NEXT: store i32 0, ptr [[PTR_SRC_IV]], align 4
; CHECK-NEXT: [[ADD_1:%.*]] = add nuw nsw i8 [[IV]], 1
-; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_1]]
-; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult i8* [[SRC_IV_1]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge i8* [[SRC_IV_1]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_1]]
+; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult ptr [[SRC_IV_1]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge ptr [[SRC_IV_1]], [[UPPER]]
; CHECK-NEXT: [[OR_2:%.*]] = or i1 [[CMP_IV_1_START]], [[CMP_IV_1_END]]
; CHECK-NEXT: br i1 [[OR_2]], label [[TRAP_BB]], label [[LOOP_BODY_2:%.*]]
; CHECK: loop.body.2:
-; CHECK-NEXT: [[PTR_SRC_IV_1:%.*]] = bitcast i8* [[SRC_IV_1]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[PTR_SRC_IV_1]], align 4
+; CHECK-NEXT: [[PTR_SRC_IV_1:%.*]] = bitcast ptr [[SRC_IV_1]] to ptr
+; CHECK-NEXT: store i32 0, ptr [[PTR_SRC_IV_1]], align 4
; CHECK-NEXT: [[ADD_2:%.*]] = add nuw nsw i8 [[IV]], 2
-; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_2]]
-; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult i8* [[SRC_IV_2]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge i8* [[SRC_IV_2]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_2]]
+; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult ptr [[SRC_IV_2]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge ptr [[SRC_IV_2]], [[UPPER]]
; CHECK-NEXT: [[OR_3:%.*]] = or i1 [[CMP_IV_2_START]], [[CMP_IV_2_END]]
; CHECK-NEXT: br i1 [[OR_3]], label [[TRAP_BB]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[PTR_SRC_IV_2:%.*]] = bitcast i8* [[SRC_IV_2]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[PTR_SRC_IV_2]], align 4
+; CHECK-NEXT: [[PTR_SRC_IV_2:%.*]] = bitcast ptr [[SRC_IV_2]] to ptr
+; CHECK-NEXT: store i32 0, ptr [[PTR_SRC_IV_2]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i8 [[IV]], 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
%or.0 = or i1 %cmp.src.start, %cmp.src.end
br i1 %or.0, label %trap.bb, label %loop.header
@@ -65,36 +65,35 @@ loop.header:
br i1 %ec, label %exit, label %loop.body
loop.body:
- %src.iv = getelementptr inbounds i8, i8* %src, i8 %iv
- %cmp.iv.start = icmp ult i8* %src.iv, %lower
- %cmp.iv.end = icmp uge i8* %src.iv, %upper
+ %src.iv = getelementptr inbounds i8, ptr %src, i8 %iv
+ %cmp.iv.start = icmp ult ptr %src.iv, %lower
+ %cmp.iv.end = icmp uge ptr %src.iv, %upper
%or.1 = or i1 %cmp.iv.start, %cmp.iv.end
br i1 %or.1, label %trap.bb, label %loop.body.1
loop.body.1:
- %ptr.src.iv = bitcast i8* %src.iv to i32*
- store i32 0, i32* %ptr.src.iv, align 4
+ %ptr.src.iv = bitcast ptr %src.iv to ptr
+ store i32 0, ptr %ptr.src.iv, align 4
%add.1 = add nuw nsw i8 %iv, 1
- %src.iv.1 = getelementptr inbounds i8, i8* %src, i8 %add.1
- %cmp.iv.1.start = icmp ult i8* %src.iv.1, %lower
- %cmp.iv.1.end = icmp uge i8* %src.iv.1, %upper
+ %src.iv.1 = getelementptr inbounds i8, ptr %src, i8 %add.1
+ %cmp.iv.1.start = icmp ult ptr %src.iv.1, %lower
+ %cmp.iv.1.end = icmp uge ptr %src.iv.1, %upper
%or.2 = or i1 %cmp.iv.1.start, %cmp.iv.1.end
br i1 %or.2, label %trap.bb, label %loop.body.2
loop.body.2:
- %ptr.src.iv.1 = bitcast i8* %src.iv.1 to i32*
- store i32 0, i32* %ptr.src.iv.1, align 4
+ %ptr.src.iv.1 = bitcast ptr %src.iv.1 to ptr
+ store i32 0, ptr %ptr.src.iv.1, align 4
%add.2 = add nuw nsw i8 %iv, 2
- %src.iv.2 = getelementptr inbounds i8, i8* %src, i8 %add.2
- %cmp.iv.2.start = icmp ult i8* %src.iv.2, %lower
- %cmp.iv.2.end = icmp uge i8* %src.iv.2, %upper
+ %src.iv.2 = getelementptr inbounds i8, ptr %src, i8 %add.2
+ %cmp.iv.2.start = icmp ult ptr %src.iv.2, %lower
+ %cmp.iv.2.end = icmp uge ptr %src.iv.2, %upper
%or.3 = or i1 %cmp.iv.2.start, %cmp.iv.2.end
br i1 %or.3, label %trap.bb, label %loop.latch
-
loop.latch:
- %ptr.src.iv.2 = bitcast i8* %src.iv.2 to i32*
- store i32 0, i32* %ptr.src.iv.2, align 4
+ %ptr.src.iv.2 = bitcast ptr %src.iv.2 to ptr
+ store i32 0, ptr %ptr.src.iv.2, align 4
%iv.next = add nuw nsw i8 %iv, 1
br label %loop.header
@@ -102,13 +101,13 @@ exit:
ret void
}
-define void @test2(i8* %src, i8* %lower, i8* %upper, i8 %N) {
+define void @test2(ptr %src, ptr %lower, ptr %upper, i8 %N) {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
-; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt i8* [[SRC]], [[SRC_END]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt ptr [[SRC]], [[SRC_END]]
; CHECK-NEXT: [[OR_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_11:%.*]] = or i1 [[OR_0]], [[CMP_OVERFLOW]]
; CHECK-NEXT: br i1 [[OR_11]], label [[TRAP_BB:%.*]], label [[LOOP_HEADER:%.*]]
@@ -120,38 +119,38 @@ define void @test2(i8* %src, i8* %lower, i8* %upper, i8 %N) {
; CHECK-NEXT: [[EC:%.*]] = icmp uge i8 [[NEXT]], [[N]]
; CHECK-NEXT: br i1 [[EC]], label [[EXIT:%.*]], label [[LOOP_BODY:%.*]]
; CHECK: loop.body:
-; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[IV]]
-; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult i8* [[SRC_IV]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge i8* [[SRC_IV]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[IV]]
+; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult ptr [[SRC_IV]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge ptr [[SRC_IV]], [[UPPER]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_START]], [[CMP_IV_END]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP_BB]], label [[LOOP_BODY_1:%.*]]
; CHECK: loop.body.1:
; CHECK-NEXT: [[ADD_1:%.*]] = add nuw nsw i8 [[IV]], 1
-; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_1]]
-; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult i8* [[SRC_IV_1]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge i8* [[SRC_IV_1]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_1]]
+; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult ptr [[SRC_IV_1]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge ptr [[SRC_IV_1]], [[UPPER]]
; CHECK-NEXT: [[OR_2:%.*]] = or i1 [[CMP_IV_1_START]], [[CMP_IV_1_END]]
; CHECK-NEXT: br i1 [[OR_2]], label [[TRAP_BB]], label [[LOOP_BODY_2:%.*]]
; CHECK: loop.body.2:
; CHECK-NEXT: [[ADD_2:%.*]] = add nuw nsw i8 [[IV]], 2
-; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_2]]
-; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult i8* [[SRC_IV_2]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge i8* [[SRC_IV_2]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_2]]
+; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult ptr [[SRC_IV_2]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge ptr [[SRC_IV_2]], [[UPPER]]
; CHECK-NEXT: [[OR_3:%.*]] = or i1 [[CMP_IV_2_START]], [[CMP_IV_2_END]]
; CHECK-NEXT: br i1 [[OR_3]], label [[TRAP_BB]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[PTR:%.*]] = bitcast i8* [[SRC_IV]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[PTR]], align 4
+; CHECK-NEXT: [[PTR:%.*]] = bitcast ptr [[SRC_IV]] to ptr
+; CHECK-NEXT: store i32 0, ptr [[PTR]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i8 [[IV]], 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
- %cmp.overflow = icmp ugt i8* %src, %src.end
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
+ %cmp.overflow = icmp ugt ptr %src, %src.end
%or.0 = or i1 %cmp.src.start, %cmp.src.end
%or.11 = or i1 %or.0, %cmp.overflow
br i1 %or.11, label %trap.bb, label %loop.header
@@ -161,36 +160,36 @@ trap.bb:
loop.header:
%iv = phi i8 [ %iv.next, %loop.latch ], [ 1, %entry ]
- %next = add nsw nuw i8 %iv, 2
+ %next = add nuw nsw i8 %iv, 2
%ec = icmp uge i8 %next, %N
br i1 %ec, label %exit, label %loop.body
loop.body:
- %src.iv = getelementptr inbounds i8, i8* %src, i8 %iv
- %cmp.iv.start = icmp ult i8* %src.iv, %lower
- %cmp.iv.end = icmp uge i8* %src.iv, %upper
+ %src.iv = getelementptr inbounds i8, ptr %src, i8 %iv
+ %cmp.iv.start = icmp ult ptr %src.iv, %lower
+ %cmp.iv.end = icmp uge ptr %src.iv, %upper
%or.1 = or i1 %cmp.iv.start, %cmp.iv.end
br i1 %or.1, label %trap.bb, label %loop.body.1
loop.body.1:
- %add.1 = add nsw nuw i8 %iv, 1
- %src.iv.1 = getelementptr inbounds i8, i8* %src, i8 %add.1
- %cmp.iv.1.start = icmp ult i8* %src.iv.1, %lower
- %cmp.iv.1.end = icmp uge i8* %src.iv.1, %upper
+ %add.1 = add nuw nsw i8 %iv, 1
+ %src.iv.1 = getelementptr inbounds i8, ptr %src, i8 %add.1
+ %cmp.iv.1.start = icmp ult ptr %src.iv.1, %lower
+ %cmp.iv.1.end = icmp uge ptr %src.iv.1, %upper
%or.2 = or i1 %cmp.iv.1.start, %cmp.iv.1.end
br i1 %or.2, label %trap.bb, label %loop.body.2
loop.body.2:
- %add.2 = add nsw nuw i8 %iv, 2
- %src.iv.2 = getelementptr inbounds i8, i8* %src, i8 %add.2
- %cmp.iv.2.start = icmp ult i8* %src.iv.2, %lower
- %cmp.iv.2.end = icmp uge i8* %src.iv.2, %upper
+ %add.2 = add nuw nsw i8 %iv, 2
+ %src.iv.2 = getelementptr inbounds i8, ptr %src, i8 %add.2
+ %cmp.iv.2.start = icmp ult ptr %src.iv.2, %lower
+ %cmp.iv.2.end = icmp uge ptr %src.iv.2, %upper
%or.3 = or i1 %cmp.iv.2.start, %cmp.iv.2.end
br i1 %or.3, label %trap.bb, label %loop.latch
loop.latch:
- %ptr = bitcast i8* %src.iv to i32*
- store i32 0, i32* %ptr, align 4
+ %ptr = bitcast ptr %src.iv to ptr
+ store i32 0, ptr %ptr, align 4
%iv.next = add nuw nsw i8 %iv, 1
br label %loop.header
@@ -198,13 +197,13 @@ exit:
ret void
}
-define void @test2_with_ne(i8* %src, i8* %lower, i8* %upper, i8 %N) {
+define void @test2_with_ne(ptr %src, ptr %lower, ptr %upper, i8 %N) {
; CHECK-LABEL: @test2_with_ne(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
-; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt i8* [[SRC]], [[SRC_END]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt ptr [[SRC]], [[SRC_END]]
; CHECK-NEXT: [[OR_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_11:%.*]] = or i1 [[OR_0]], [[CMP_OVERFLOW]]
; CHECK-NEXT: br i1 [[OR_11]], label [[TRAP_BB:%.*]], label [[LOOP_HEADER:%.*]]
@@ -216,38 +215,38 @@ define void @test2_with_ne(i8* %src, i8* %lower, i8* %upper, i8 %N) {
; CHECK-NEXT: [[EC:%.*]] = icmp eq i8 [[NEXT]], [[N]]
; CHECK-NEXT: br i1 [[EC]], label [[EXIT:%.*]], label [[LOOP_BODY:%.*]]
; CHECK: loop.body:
-; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[IV]]
-; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult i8* [[SRC_IV]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge i8* [[SRC_IV]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[IV]]
+; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult ptr [[SRC_IV]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge ptr [[SRC_IV]], [[UPPER]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_START]], [[CMP_IV_END]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP_BB]], label [[LOOP_BODY_1:%.*]]
; CHECK: loop.body.1:
; CHECK-NEXT: [[ADD_1:%.*]] = add nuw nsw i8 [[IV]], 1
-; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_1]]
-; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult i8* [[SRC_IV_1]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge i8* [[SRC_IV_1]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_1]]
+; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult ptr [[SRC_IV_1]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge ptr [[SRC_IV_1]], [[UPPER]]
; CHECK-NEXT: [[OR_2:%.*]] = or i1 [[CMP_IV_1_START]], [[CMP_IV_1_END]]
; CHECK-NEXT: br i1 [[OR_2]], label [[TRAP_BB]], label [[LOOP_BODY_2:%.*]]
; CHECK: loop.body.2:
; CHECK-NEXT: [[ADD_2:%.*]] = add nuw nsw i8 [[IV]], 2
-; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_2]]
-; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult i8* [[SRC_IV_2]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge i8* [[SRC_IV_2]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_2]]
+; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult ptr [[SRC_IV_2]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge ptr [[SRC_IV_2]], [[UPPER]]
; CHECK-NEXT: [[OR_3:%.*]] = or i1 [[CMP_IV_2_START]], [[CMP_IV_2_END]]
; CHECK-NEXT: br i1 [[OR_3]], label [[TRAP_BB]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[PTR:%.*]] = bitcast i8* [[SRC_IV]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[PTR]], align 4
+; CHECK-NEXT: [[PTR:%.*]] = bitcast ptr [[SRC_IV]] to ptr
+; CHECK-NEXT: store i32 0, ptr [[PTR]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i8 [[IV]], 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
- %cmp.overflow = icmp ugt i8* %src, %src.end
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
+ %cmp.overflow = icmp ugt ptr %src, %src.end
%or.0 = or i1 %cmp.src.start, %cmp.src.end
%or.11 = or i1 %or.0, %cmp.overflow
br i1 %or.11, label %trap.bb, label %loop.header
@@ -257,36 +256,36 @@ trap.bb:
loop.header:
%iv = phi i8 [ %iv.next, %loop.latch ], [ 1, %entry ]
- %next = add nsw nuw i8 %iv, 1
+ %next = add nuw nsw i8 %iv, 1
%ec = icmp eq i8 %next, %N
br i1 %ec, label %exit, label %loop.body
loop.body:
- %src.iv = getelementptr inbounds i8, i8* %src, i8 %iv
- %cmp.iv.start = icmp ult i8* %src.iv, %lower
- %cmp.iv.end = icmp uge i8* %src.iv, %upper
+ %src.iv = getelementptr inbounds i8, ptr %src, i8 %iv
+ %cmp.iv.start = icmp ult ptr %src.iv, %lower
+ %cmp.iv.end = icmp uge ptr %src.iv, %upper
%or.1 = or i1 %cmp.iv.start, %cmp.iv.end
br i1 %or.1, label %trap.bb, label %loop.body.1
loop.body.1:
- %add.1 = add nsw nuw i8 %iv, 1
- %src.iv.1 = getelementptr inbounds i8, i8* %src, i8 %add.1
- %cmp.iv.1.start = icmp ult i8* %src.iv.1, %lower
- %cmp.iv.1.end = icmp uge i8* %src.iv.1, %upper
+ %add.1 = add nuw nsw i8 %iv, 1
+ %src.iv.1 = getelementptr inbounds i8, ptr %src, i8 %add.1
+ %cmp.iv.1.start = icmp ult ptr %src.iv.1, %lower
+ %cmp.iv.1.end = icmp uge ptr %src.iv.1, %upper
%or.2 = or i1 %cmp.iv.1.start, %cmp.iv.1.end
br i1 %or.2, label %trap.bb, label %loop.body.2
loop.body.2:
- %add.2 = add nsw nuw i8 %iv, 2
- %src.iv.2 = getelementptr inbounds i8, i8* %src, i8 %add.2
- %cmp.iv.2.start = icmp ult i8* %src.iv.2, %lower
- %cmp.iv.2.end = icmp uge i8* %src.iv.2, %upper
+ %add.2 = add nuw nsw i8 %iv, 2
+ %src.iv.2 = getelementptr inbounds i8, ptr %src, i8 %add.2
+ %cmp.iv.2.start = icmp ult ptr %src.iv.2, %lower
+ %cmp.iv.2.end = icmp uge ptr %src.iv.2, %upper
%or.3 = or i1 %cmp.iv.2.start, %cmp.iv.2.end
br i1 %or.3, label %trap.bb, label %loop.latch
loop.latch:
- %ptr = bitcast i8* %src.iv to i32*
- store i32 0, i32* %ptr, align 4
+ %ptr = bitcast ptr %src.iv to ptr
+ store i32 0, ptr %ptr, align 4
%iv.next = add nuw nsw i8 %iv, 1
br label %loop.header
@@ -294,14 +293,13 @@ exit:
ret void
}
-
-define void @test3(i8* %src, i8* %lower, i8* %upper, i8 %N) {
+define void @test3(ptr %src, ptr %lower, ptr %upper, i8 %N) {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i8 [[N:%.*]]
-; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult i8* [[SRC]], [[LOWER:%.*]]
-; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge i8* [[SRC_END]], [[UPPER:%.*]]
-; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt i8* [[SRC]], [[SRC_END]]
+; CHECK-NEXT: [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i8 [[N:%.*]]
+; CHECK-NEXT: [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
+; CHECK-NEXT: [[CMP_OVERFLOW:%.*]] = icmp ugt ptr [[SRC]], [[SRC_END]]
; CHECK-NEXT: [[OR_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
; CHECK-NEXT: [[OR_11:%.*]] = or i1 [[OR_0]], [[CMP_OVERFLOW]]
; CHECK-NEXT: br i1 [[OR_11]], label [[TRAP_BB:%.*]], label [[LOOP_HEADER:%.*]]
@@ -313,37 +311,37 @@ define void @test3(i8* %src, i8* %lower, i8* %upper, i8 %N) {
; CHECK-NEXT: [[EC:%.*]] = icmp ult i8 [[NEXT]], [[N]]
; CHECK-NEXT: br i1 [[EC]], label [[LOOP_BODY:%.*]], label [[EXIT:%.*]]
; CHECK: loop.body:
-; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[IV]]
-; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult i8* [[SRC_IV]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge i8* [[SRC_IV]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[IV]]
+; CHECK-NEXT: [[CMP_IV_START:%.*]] = icmp ult ptr [[SRC_IV]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_END:%.*]] = icmp uge ptr [[SRC_IV]], [[UPPER]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_START]], [[CMP_IV_END]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP_BB]], label [[LOOP_BODY_1:%.*]]
; CHECK: loop.body.1:
-; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[NEXT]]
-; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult i8* [[SRC_IV_1]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge i8* [[SRC_IV_1]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_1:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[NEXT]]
+; CHECK-NEXT: [[CMP_IV_1_START:%.*]] = icmp ult ptr [[SRC_IV_1]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_1_END:%.*]] = icmp uge ptr [[SRC_IV_1]], [[UPPER]]
; CHECK-NEXT: [[OR_2:%.*]] = or i1 [[CMP_IV_1_START]], [[CMP_IV_1_END]]
; CHECK-NEXT: br i1 [[OR_2]], label [[TRAP_BB]], label [[LOOP_BODY_2:%.*]]
; CHECK: loop.body.2:
; CHECK-NEXT: [[ADD_2:%.*]] = add nuw nsw i8 [[IV]], 2
-; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i8 [[ADD_2]]
-; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult i8* [[SRC_IV_2]], [[LOWER]]
-; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge i8* [[SRC_IV_2]], [[UPPER]]
+; CHECK-NEXT: [[SRC_IV_2:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i8 [[ADD_2]]
+; CHECK-NEXT: [[CMP_IV_2_START:%.*]] = icmp ult ptr [[SRC_IV_2]], [[LOWER]]
+; CHECK-NEXT: [[CMP_IV_2_END:%.*]] = icmp uge ptr [[SRC_IV_2]], [[UPPER]]
; CHECK-NEXT: [[OR_3:%.*]] = or i1 [[CMP_IV_2_START]], [[CMP_IV_2_END]]
; CHECK-NEXT: br i1 [[OR_3]], label [[TRAP_BB]], label [[LOOP_LATCH]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[PTR:%.*]] = bitcast i8* [[SRC_IV]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[PTR]], align 4
+; CHECK-NEXT: [[PTR:%.*]] = bitcast ptr [[SRC_IV]] to ptr
+; CHECK-NEXT: store i32 0, ptr [[PTR]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i8 [[IV]], 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- %src.end = getelementptr inbounds i8, i8* %src, i8 %N
- %cmp.src.start = icmp ult i8* %src, %lower
- %cmp.src.end = icmp uge i8* %src.end, %upper
- %cmp.overflow = icmp ugt i8* %src, %src.end
+ %src.end = getelementptr inbounds i8, ptr %src, i8 %N
+ %cmp.src.start = icmp ult ptr %src, %lower
+ %cmp.src.end = icmp uge ptr %src.end, %upper
+ %cmp.overflow = icmp ugt ptr %src, %src.end
%or.0 = or i1 %cmp.src.start, %cmp.src.end
%or.11 = or i1 %or.0, %cmp.overflow
br i1 %or.11, label %trap.bb, label %loop.header
@@ -358,30 +356,30 @@ loop.header:
br i1 %ec, label %loop.body, label %exit
loop.body:
- %src.iv = getelementptr inbounds i8, i8* %src, i8 %iv
- %cmp.iv.start = icmp ult i8* %src.iv, %lower
- %cmp.iv.end = icmp uge i8* %src.iv, %upper
+ %src.iv = getelementptr inbounds i8, ptr %src, i8 %iv
+ %cmp.iv.start = icmp ult ptr %src.iv, %lower
+ %cmp.iv.end = icmp uge ptr %src.iv, %upper
%or.1 = or i1 %cmp.iv.start, %cmp.iv.end
br i1 %or.1, label %trap.bb, label %loop.body.1
loop.body.1:
- %src.iv.1 = getelementptr inbounds i8, i8* %src, i8 %next
- %cmp.iv.1.start = icmp ult i8* %src.iv.1, %lower
- %cmp.iv.1.end = icmp uge i8* %src.iv.1, %upper
+ %src.iv.1 = getelementptr inbounds i8, ptr %src, i8 %next
+ %cmp.iv.1.start = icmp ult ptr %src.iv.1, %lower
+ %cmp.iv.1.end = icmp uge ptr %src.iv.1, %upper
%or.2 = or i1 %cmp.iv.1.start, %cmp.iv.1.end
br i1 %or.2, label %trap.bb, label %loop.body.2
loop.body.2:
- %add.2 = add nsw nuw i8 %iv, 2
- %src.iv.2 = getelementptr inbounds i8, i8* %src, i8 %add.2
- %cmp.iv.2.start = icmp ult i8* %src.iv.2, %lower
- %cmp.iv.2.end = icmp uge i8* %src.iv.2, %upper
+ %add.2 = add nuw nsw i8 %iv, 2
+ %src.iv.2 = getelementptr inbounds i8, ptr %src, i8 %add.2
+ %cmp.iv.2.start = icmp ult ptr %src.iv.2, %lower
+ %cmp.iv.2.end = icmp uge ptr %src.iv.2, %upper
%or.3 = or i1 %cmp.iv.2.start, %cmp.iv.2.end
br i1 %or.3, label %trap.bb, label %loop.latch
loop.latch:
- %ptr = bitcast i8* %src.iv to i32*
- store i32 0, i32* %ptr, align 4
+ %ptr = bitcast ptr %src.iv to ptr
+ store i32 0, ptr %ptr, align 4
%iv.next = add nuw nsw i8 %iv, 1
br label %loop.header
@@ -390,14 +388,14 @@ exit:
}
; Cannot remove checks, because %n may be negative.
-define void @ne_check_in_loop_no_zext_n_may_be_negative(i8* %ptr, i8* %lower, i8* %upper, i16 %n) {
+define void @ne_check_in_loop_no_zext_n_may_be_negative(ptr %ptr, ptr %lower, ptr %upper, i16 %n) {
; CHECK-LABEL: @ne_check_in_loop_no_zext_n_may_be_negative(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult i8* [[PTR:%.*]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult ptr [[PTR:%.*]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_LOWER]], label [[TRAP:%.*]], label [[PRE:%.*]]
; CHECK: pre:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[N:%.*]]
-; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult i8* [[ADD_PTR]], [[UPPER:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[N:%.*]]
+; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult ptr [[ADD_PTR]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_N_UPPER]], label [[FOR_COND_PREHEADER:%.*]], label [[TRAP]]
; CHECK: for.cond.preheader:
; CHECK-NEXT: br label [[FOR_HEADER:%.*]]
@@ -408,32 +406,32 @@ define void @ne_check_in_loop_no_zext_n_may_be_negative(i8* %ptr, i8* %lower, i8
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i16 [[IV]], [[N]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
; CHECK: for.body:
-; CHECK-NEXT: [[GEP_IV:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV]]
-; CHECK-NEXT: [[CMP_IV_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[GEP_IV]]
-; CHECK-NEXT: [[CMP_IV_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[GEP_IV]]
+; CHECK-NEXT: [[GEP_IV:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV]]
+; CHECK-NEXT: [[CMP_IV_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[GEP_IV]]
+; CHECK-NEXT: [[CMP_IV_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[GEP_IV]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP_IV_LOWER]], [[CMP_IV_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[FOR_BODY_1:%.*]]
; CHECK: for.body.1:
; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i16 [[IV]], 1
-; CHECK-NEXT: [[GEP_IV_1:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[ADD]]
-; CHECK-NEXT: [[CMP_IV_1_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[GEP_IV_1]]
-; CHECK-NEXT: [[CMP_IV_1_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[GEP_IV_1]]
+; CHECK-NEXT: [[GEP_IV_1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[ADD]]
+; CHECK-NEXT: [[CMP_IV_1_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[GEP_IV_1]]
+; CHECK-NEXT: [[CMP_IV_1_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[GEP_IV_1]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_1_LOWER]], [[CMP_IV_1_UPPER]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP]], label [[FOR_LATCH]]
; CHECK: for.latch:
-; CHECK-NEXT: store i8 0, i8* [[GEP_IV]], align 4
+; CHECK-NEXT: store i8 0, ptr [[GEP_IV]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1
; CHECK-NEXT: br label [[FOR_HEADER]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
entry:
- %cmp.ptr.lower = icmp ult i8* %ptr, %lower
+ %cmp.ptr.lower = icmp ult ptr %ptr, %lower
br i1 %cmp.ptr.lower, label %trap, label %pre
pre:
- %add.ptr = getelementptr inbounds i8, i8* %ptr, i16 %n
- %cmp.ptr.n.upper = icmp ult i8* %add.ptr, %upper
+ %add.ptr = getelementptr inbounds i8, ptr %ptr, i16 %n
+ %cmp.ptr.n.upper = icmp ult ptr %add.ptr, %upper
br i1 %cmp.ptr.n.upper, label %for.cond.preheader, label %trap
for.cond.preheader:
@@ -448,22 +446,22 @@ for.header:
br i1 %exitcond, label %for.body, label %for.end
for.body:
- %gep.iv = getelementptr inbounds i8, i8* %ptr, i16 %iv
- %cmp.iv.lower = icmp ugt i8* %lower, %gep.iv
- %cmp.iv.upper = icmp ule i8* %upper, %gep.iv
+ %gep.iv = getelementptr inbounds i8, ptr %ptr, i16 %iv
+ %cmp.iv.lower = icmp ugt ptr %lower, %gep.iv
+ %cmp.iv.upper = icmp ule ptr %upper, %gep.iv
%or = or i1 %cmp.iv.lower, %cmp.iv.upper
br i1 %or, label %trap, label %for.body.1
for.body.1:
%add = add nuw nsw i16 %iv, 1
- %gep.iv.1 = getelementptr inbounds i8, i8* %ptr, i16 %add
- %cmp.iv.1.lower = icmp ugt i8* %lower, %gep.iv.1
- %cmp.iv.1.upper = icmp ule i8* %upper, %gep.iv.1
+ %gep.iv.1 = getelementptr inbounds i8, ptr %ptr, i16 %add
+ %cmp.iv.1.lower = icmp ugt ptr %lower, %gep.iv.1
+ %cmp.iv.1.upper = icmp ule ptr %upper, %gep.iv.1
%or.1 = or i1 %cmp.iv.1.lower, %cmp.iv.1.upper
br i1 %or.1, label %trap, label %for.latch
for.latch:
- store i8 0, i8* %gep.iv, align 4
+ store i8 0, ptr %gep.iv, align 4
%iv.next = add nuw nsw i16 %iv, 1
br label %for.header
@@ -472,16 +470,16 @@ for.end:
}
; Should be able to remove the checks in the loop, because %n is signed positive.
-define void @ne_check_in_loop_no_zext_n_positive_check(i8* %ptr, i8* %lower, i8* %upper, i16 %n) {
+define void @ne_check_in_loop_no_zext_n_positive_check(ptr %ptr, ptr %lower, ptr %upper, i16 %n) {
; CHECK-LABEL: @ne_check_in_loop_no_zext_n_positive_check(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[N_SIGNED_POSITIVE:%.*]] = icmp slt i16 [[N:%.*]], 0
-; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult i8* [[PTR:%.*]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult ptr [[PTR:%.*]], [[LOWER:%.*]]
; CHECK-NEXT: [[OR_T:%.*]] = or i1 [[N_SIGNED_POSITIVE]], [[CMP_PTR_LOWER]]
; CHECK-NEXT: br i1 [[OR_T]], label [[TRAP:%.*]], label [[PRE:%.*]]
; CHECK: pre:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[N]]
-; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult i8* [[ADD_PTR]], [[UPPER:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[N]]
+; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult ptr [[ADD_PTR]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_N_UPPER]], label [[FOR_COND_PREHEADER:%.*]], label [[TRAP]]
; CHECK: for.cond.preheader:
; CHECK-NEXT: br label [[FOR_HEADER:%.*]]
@@ -492,20 +490,20 @@ define void @ne_check_in_loop_no_zext_n_positive_check(i8* %ptr, i8* %lower, i8*
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i16 [[IV]], [[N]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
; CHECK: for.body:
-; CHECK-NEXT: [[GEP_IV:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV]]
-; CHECK-NEXT: [[CMP_IV_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[GEP_IV]]
-; CHECK-NEXT: [[CMP_IV_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[GEP_IV]]
+; CHECK-NEXT: [[GEP_IV:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV]]
+; CHECK-NEXT: [[CMP_IV_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[GEP_IV]]
+; CHECK-NEXT: [[CMP_IV_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[GEP_IV]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP_IV_LOWER]], [[CMP_IV_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[FOR_BODY_1:%.*]]
; CHECK: for.body.1:
; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i16 [[IV]], 1
-; CHECK-NEXT: [[GEP_IV_1:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[ADD]]
-; CHECK-NEXT: [[CMP_IV_1_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[GEP_IV_1]]
-; CHECK-NEXT: [[CMP_IV_1_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[GEP_IV_1]]
+; CHECK-NEXT: [[GEP_IV_1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[ADD]]
+; CHECK-NEXT: [[CMP_IV_1_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[GEP_IV_1]]
+; CHECK-NEXT: [[CMP_IV_1_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[GEP_IV_1]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_1_LOWER]], [[CMP_IV_1_UPPER]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP]], label [[FOR_LATCH]]
; CHECK: for.latch:
-; CHECK-NEXT: store i8 0, i8* [[GEP_IV]], align 4
+; CHECK-NEXT: store i8 0, ptr [[GEP_IV]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1
; CHECK-NEXT: br label [[FOR_HEADER]]
; CHECK: for.end:
@@ -513,13 +511,13 @@ define void @ne_check_in_loop_no_zext_n_positive_check(i8* %ptr, i8* %lower, i8*
;
entry:
%n.signed.positive = icmp slt i16 %n, 0
- %cmp.ptr.lower = icmp ult i8* %ptr, %lower
+ %cmp.ptr.lower = icmp ult ptr %ptr, %lower
%or.t = or i1 %n.signed.positive, %cmp.ptr.lower
br i1 %or.t, label %trap, label %pre
pre:
- %add.ptr = getelementptr inbounds i8, i8* %ptr, i16 %n
- %cmp.ptr.n.upper = icmp ult i8* %add.ptr, %upper
+ %add.ptr = getelementptr inbounds i8, ptr %ptr, i16 %n
+ %cmp.ptr.n.upper = icmp ult ptr %add.ptr, %upper
br i1 %cmp.ptr.n.upper, label %for.cond.preheader, label %trap
for.cond.preheader:
@@ -534,22 +532,22 @@ for.header:
br i1 %exitcond, label %for.body, label %for.end
for.body:
- %gep.iv = getelementptr inbounds i8, i8* %ptr, i16 %iv
- %cmp.iv.lower = icmp ugt i8* %lower, %gep.iv
- %cmp.iv.upper = icmp ule i8* %upper, %gep.iv
+ %gep.iv = getelementptr inbounds i8, ptr %ptr, i16 %iv
+ %cmp.iv.lower = icmp ugt ptr %lower, %gep.iv
+ %cmp.iv.upper = icmp ule ptr %upper, %gep.iv
%or = or i1 %cmp.iv.lower, %cmp.iv.upper
br i1 %or, label %trap, label %for.body.1
for.body.1:
%add = add nuw nsw i16 %iv, 1
- %gep.iv.1 = getelementptr inbounds i8, i8* %ptr, i16 %add
- %cmp.iv.1.lower = icmp ugt i8* %lower, %gep.iv.1
- %cmp.iv.1.upper = icmp ule i8* %upper, %gep.iv.1
+ %gep.iv.1 = getelementptr inbounds i8, ptr %ptr, i16 %add
+ %cmp.iv.1.lower = icmp ugt ptr %lower, %gep.iv.1
+ %cmp.iv.1.upper = icmp ule ptr %upper, %gep.iv.1
%or.1 = or i1 %cmp.iv.1.lower, %cmp.iv.1.upper
br i1 %or.1, label %trap, label %for.latch
for.latch:
- store i8 0, i8* %gep.iv, align 4
+ store i8 0, ptr %gep.iv, align 4
%iv.next = add nuw nsw i16 %iv, 1
br label %for.header
@@ -559,15 +557,15 @@ for.end:
; Make sure icmp ne of the induction variable in the loop body can be handled
; and is treated as ule.
-define void @ne_check_in_loop_with_zext(i8* %ptr, i8* %lower, i8* %upper, i8 %n) {
+define void @ne_check_in_loop_with_zext(ptr %ptr, ptr %lower, ptr %upper, i8 %n) {
; CHECK-LABEL: @ne_check_in_loop_with_zext(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult i8* [[PTR:%.*]], [[LOWER:%.*]]
+; CHECK-NEXT: [[CMP_PTR_LOWER:%.*]] = icmp ult ptr [[PTR:%.*]], [[LOWER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_LOWER]], label [[TRAP:%.*]], label [[PRE:%.*]]
; CHECK: pre:
; CHECK-NEXT: [[IDX_EXT:%.*]] = zext i8 [[N:%.*]] to i16
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IDX_EXT]]
-; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult i8* [[ADD_PTR]], [[UPPER:%.*]]
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IDX_EXT]]
+; CHECK-NEXT: [[CMP_PTR_N_UPPER:%.*]] = icmp ult ptr [[ADD_PTR]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[CMP_PTR_N_UPPER]], label [[FOR_COND_PREHEADER:%.*]], label [[TRAP]]
; CHECK: for.cond.preheader:
; CHECK-NEXT: br label [[FOR_HEADER:%.*]]
@@ -578,33 +576,33 @@ define void @ne_check_in_loop_with_zext(i8* %ptr, i8* %lower, i8* %upper, i8 %n)
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i16 [[IV]], [[IDX_EXT]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
; CHECK: for.body:
-; CHECK-NEXT: [[GEP_IV:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[IV]]
-; CHECK-NEXT: [[CMP_IV_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[GEP_IV]]
-; CHECK-NEXT: [[CMP_IV_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[GEP_IV]]
+; CHECK-NEXT: [[GEP_IV:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[IV]]
+; CHECK-NEXT: [[CMP_IV_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[GEP_IV]]
+; CHECK-NEXT: [[CMP_IV_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[GEP_IV]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP_IV_LOWER]], [[CMP_IV_UPPER]]
; CHECK-NEXT: br i1 [[OR]], label [[TRAP]], label [[FOR_BODY_1:%.*]]
; CHECK: for.body.1:
; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i16 [[IV]], 1
-; CHECK-NEXT: [[GEP_IV_1:%.*]] = getelementptr inbounds i8, i8* [[PTR]], i16 [[ADD]]
-; CHECK-NEXT: [[CMP_IV_1_LOWER:%.*]] = icmp ugt i8* [[LOWER]], [[GEP_IV_1]]
-; CHECK-NEXT: [[CMP_IV_1_UPPER:%.*]] = icmp ule i8* [[UPPER]], [[GEP_IV_1]]
+; CHECK-NEXT: [[GEP_IV_1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i16 [[ADD]]
+; CHECK-NEXT: [[CMP_IV_1_LOWER:%.*]] = icmp ugt ptr [[LOWER]], [[GEP_IV_1]]
+; CHECK-NEXT: [[CMP_IV_1_UPPER:%.*]] = icmp ule ptr [[UPPER]], [[GEP_IV_1]]
; CHECK-NEXT: [[OR_1:%.*]] = or i1 [[CMP_IV_1_LOWER]], [[CMP_IV_1_UPPER]]
; CHECK-NEXT: br i1 [[OR_1]], label [[TRAP]], label [[FOR_LATCH]]
; CHECK: for.latch:
-; CHECK-NEXT: store i8 0, i8* [[GEP_IV]], align 4
+; CHECK-NEXT: store i8 0, ptr [[GEP_IV]], align 4
; CHECK-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1
; CHECK-NEXT: br label [[FOR_HEADER]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
entry:
- %cmp.ptr.lower = icmp ult i8* %ptr, %lower
+ %cmp.ptr.lower = icmp ult ptr %ptr, %lower
br i1 %cmp.ptr.lower, label %trap, label %pre
pre:
%idx.ext = zext i8 %n to i16
- %add.ptr = getelementptr inbounds i8, i8* %ptr, i16 %idx.ext
- %cmp.ptr.n.upper = icmp ult i8* %add.ptr, %upper
+ %add.ptr = getelementptr inbounds i8, ptr %ptr, i16 %idx.ext
+ %cmp.ptr.n.upper = icmp ult ptr %add.ptr, %upper
br i1 %cmp.ptr.n.upper, label %for.cond.preheader, label %trap
for.cond.preheader:
@@ -619,22 +617,22 @@ for.header:
br i1 %exitcond, label %for.body, label %for.end
for.body:
- %gep.iv = getelementptr inbounds i8, i8* %ptr, i16 %iv
- %cmp.iv.lower = icmp ugt i8* %lower, %gep.iv
- %cmp.iv.upper = icmp ule i8* %upper, %gep.iv
+ %gep.iv = getelementptr inbounds i8, ptr %ptr, i16 %iv
+ %cmp.iv.lower = icmp ugt ptr %lower, %gep.iv
+ %cmp.iv.upper = icmp ule ptr %upper, %gep.iv
%or = or i1 %cmp.iv.lower, %cmp.iv.upper
br i1 %or, label %trap, label %for.body.1
for.body.1:
%add = add nuw nsw i16 %iv, 1
- %gep.iv.1 = getelementptr inbounds i8, i8* %ptr, i16 %add
- %cmp.iv.1.lower = icmp ugt i8* %lower, %gep.iv.1
- %cmp.iv.1.upper = icmp ule i8* %upper, %gep.iv.1
+ %gep.iv.1 = getelementptr inbounds i8, ptr %ptr, i16 %add
+ %cmp.iv.1.lower = icmp ugt ptr %lower, %gep.iv.1
+ %cmp.iv.1.upper = icmp ule ptr %upper, %gep.iv.1
%or.1 = or i1 %cmp.iv.1.lower, %cmp.iv.1.upper
br i1 %or.1, label %trap, label %for.latch
for.latch:
- store i8 0, i8* %gep.iv, align 4
+ store i8 0, ptr %gep.iv, align 4
%iv.next = add nuw nsw i16 %iv, 1
br label %for.header
@@ -642,7 +640,7 @@ for.end:
ret void
}
-define void @test_ptr_need_one_upper_check(i32* readonly %src, i32* %dst, i32 %n) {
+define void @test_ptr_need_one_upper_check(ptr readonly %src, ptr %dst, i32 %n) {
; CHECK-LABEL: @test_ptr_need_one_upper_check(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP_HEADER:%.*]]
@@ -652,17 +650,17 @@ define void @test_ptr_need_one_upper_check(i32* readonly %src, i32* %dst, i32 %n
; CHECK-NEXT: br i1 [[CMP]], label [[LOOP_CHECK_1:%.*]], label [[EXIT:%.*]]
; CHECK: loop.check.1:
; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[N]] to i64
-; CHECK-NEXT: [[SRC_UPPER:%.*]] = getelementptr inbounds i32, i32* [[SRC:%.*]], i64 [[TMP0]]
+; CHECK-NEXT: [[SRC_UPPER:%.*]] = getelementptr inbounds i32, ptr [[SRC:%.*]], i64 [[TMP0]]
; CHECK-NEXT: [[ADD]] = add nuw nsw i32 [[I_0]], 2
; CHECK-NEXT: [[IDXPROM:%.*]] = zext i32 [[ADD]] to i64
-; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[IDXPROM]]
-; CHECK-NEXT: [[CMP_SRC_IDX_UPPER:%.*]] = icmp ult i32* [[SRC_IDX]], [[SRC_UPPER]]
+; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[IDXPROM]]
+; CHECK-NEXT: [[CMP_SRC_IDX_UPPER:%.*]] = icmp ult ptr [[SRC_IDX]], [[SRC_UPPER]]
; CHECK-NEXT: call void @use(i1 [[CMP_SRC_IDX_UPPER]])
; CHECK-NEXT: br i1 [[CMP_SRC_IDX_UPPER]], label [[LOOP_LATCH:%.*]], label [[EXIT]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[DST_UPPER:%.*]] = getelementptr inbounds i32, i32* [[DST:%.*]], i64 [[TMP0]]
-; CHECK-NEXT: [[DST_IDX:%.*]] = getelementptr inbounds i32, i32* [[DST]], i64 [[IDXPROM]]
-; CHECK-NEXT: [[CMP_DST_IDX_UPPER:%.*]] = icmp ult i32* [[DST_IDX]], [[DST_UPPER]]
+; CHECK-NEXT: [[DST_UPPER:%.*]] = getelementptr inbounds i32, ptr [[DST:%.*]], i64 [[TMP0]]
+; CHECK-NEXT: [[DST_IDX:%.*]] = getelementptr inbounds i32, ptr [[DST]], i64 [[IDXPROM]]
+; CHECK-NEXT: [[CMP_DST_IDX_UPPER:%.*]] = icmp ult ptr [[DST_IDX]], [[DST_UPPER]]
; CHECK-NEXT: call void @use(i1 true)
; CHECK-NEXT: br i1 true, label [[LOOP_LATCH_2]], label [[EXIT]]
; CHECK: loop.latch.2:
@@ -680,18 +678,18 @@ loop.header:
loop.check.1:
%0 = zext i32 %n to i64
- %src.upper = getelementptr inbounds i32, i32* %src, i64 %0
+ %src.upper = getelementptr inbounds i32, ptr %src, i64 %0
%add = add nuw nsw i32 %i.0, 2
%idxprom = zext i32 %add to i64
- %src.idx = getelementptr inbounds i32, i32* %src, i64 %idxprom
- %cmp.src.idx.upper = icmp ult i32* %src.idx, %src.upper
+ %src.idx = getelementptr inbounds i32, ptr %src, i64 %idxprom
+ %cmp.src.idx.upper = icmp ult ptr %src.idx, %src.upper
call void @use(i1 %cmp.src.idx.upper)
br i1 %cmp.src.idx.upper, label %loop.latch, label %exit
loop.latch:
- %dst.upper = getelementptr inbounds i32, i32* %dst, i64 %0
- %dst.idx = getelementptr inbounds i32, i32* %dst, i64 %idxprom
- %cmp.dst.idx.upper = icmp ult i32* %dst.idx, %dst.upper
+ %dst.upper = getelementptr inbounds i32, ptr %dst, i64 %0
+ %dst.idx = getelementptr inbounds i32, ptr %dst, i64 %idxprom
+ %cmp.dst.idx.upper = icmp ult ptr %dst.idx, %dst.upper
call void @use(i1 %cmp.dst.idx.upper)
br i1 %cmp.dst.idx.upper, label %loop.latch.2, label %exit
@@ -703,7 +701,7 @@ exit:
}
; Same as test_ptr_need_one_upper_check, but without inbounds GEP.
-define void @test_ptr_need_one_upper_check_no_inbounds(i32* readonly %src, i32* %dst, i32 %n) {
+define void @test_ptr_need_one_upper_check_no_inbounds(ptr readonly %src, ptr %dst, i32 %n) {
; CHECK-LABEL: @test_ptr_need_one_upper_check_no_inbounds(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP_HEADER:%.*]]
@@ -713,17 +711,17 @@ define void @test_ptr_need_one_upper_check_no_inbounds(i32* readonly %src, i32*
; CHECK-NEXT: br i1 [[CMP]], label [[LOOP_CHECK_1:%.*]], label [[EXIT:%.*]]
; CHECK: loop.check.1:
; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[N]] to i64
-; CHECK-NEXT: [[SRC_UPPER:%.*]] = getelementptr i32, i32* [[SRC:%.*]], i64 [[TMP0]]
+; CHECK-NEXT: [[SRC_UPPER:%.*]] = getelementptr i32, ptr [[SRC:%.*]], i64 [[TMP0]]
; CHECK-NEXT: [[ADD]] = add nuw nsw i32 [[I_0]], 2
; CHECK-NEXT: [[IDXPROM:%.*]] = zext i32 [[ADD]] to i64
-; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i32, i32* [[SRC]], i64 [[IDXPROM]]
-; CHECK-NEXT: [[CMP_SRC_IDX_UPPER:%.*]] = icmp ult i32* [[SRC_IDX]], [[SRC_UPPER]]
+; CHECK-NEXT: [[SRC_IDX:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[IDXPROM]]
+; CHECK-NEXT: [[CMP_SRC_IDX_UPPER:%.*]] = icmp ult ptr [[SRC_IDX]], [[SRC_UPPER]]
; CHECK-NEXT: call void @use(i1 [[CMP_SRC_IDX_UPPER]])
; CHECK-NEXT: br i1 [[CMP_SRC_IDX_UPPER]], label [[LOOP_LATCH:%.*]], label [[EXIT]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[DST_UPPER:%.*]] = getelementptr i32, i32* [[DST:%.*]], i64 [[TMP0]]
-; CHECK-NEXT: [[DST_IDX:%.*]] = getelementptr inbounds i32, i32* [[DST]], i64 [[IDXPROM]]
-; CHECK-NEXT: [[CMP_DST_IDX_UPPER:%.*]] = icmp ult i32* [[DST_IDX]], [[DST_UPPER]]
+; CHECK-NEXT: [[DST_UPPER:%.*]] = getelementptr i32, ptr [[DST:%.*]], i64 [[TMP0]]
+; CHECK-NEXT: [[DST_IDX:%.*]] = getelementptr inbounds i32, ptr [[DST]], i64 [[IDXPROM]]
+; CHECK-NEXT: [[CMP_DST_IDX_UPPER:%.*]] = icmp ult ptr [[DST_IDX]], [[DST_UPPER]]
; CHECK-NEXT: call void @use(i1 [[CMP_DST_IDX_UPPER]])
; CHECK-NEXT: br i1 [[CMP_DST_IDX_UPPER]], label [[LOOP_LATCH_2]], label [[EXIT]]
; CHECK: loop.latch.2:
@@ -741,18 +739,18 @@ loop.header:
loop.check.1:
%0 = zext i32 %n to i64
- %src.upper = getelementptr i32, i32* %src, i64 %0
+ %src.upper = getelementptr i32, ptr %src, i64 %0
%add = add nuw nsw i32 %i.0, 2
%idxprom = zext i32 %add to i64
- %src.idx = getelementptr inbounds i32, i32* %src, i64 %idxprom
- %cmp.src.idx.upper = icmp ult i32* %src.idx, %src.upper
+ %src.idx = getelementptr inbounds i32, ptr %src, i64 %idxprom
+ %cmp.src.idx.upper = icmp ult ptr %src.idx, %src.upper
call void @use(i1 %cmp.src.idx.upper)
br i1 %cmp.src.idx.upper, label %loop.latch, label %exit
loop.latch:
- %dst.upper = getelementptr i32, i32* %dst, i64 %0
- %dst.idx = getelementptr inbounds i32, i32* %dst, i64 %idxprom
- %cmp.dst.idx.upper = icmp ult i32* %dst.idx, %dst.upper
+ %dst.upper = getelementptr i32, ptr %dst, i64 %0
+ %dst.idx = getelementptr inbounds i32, ptr %dst, i64 %idxprom
+ %cmp.dst.idx.upper = icmp ult ptr %dst.idx, %dst.upper
call void @use(i1 %cmp.dst.idx.upper)
br i1 %cmp.dst.idx.upper, label %loop.latch.2, label %exit
diff --git a/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll b/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll
index 063fe9d30c466..00cd3a77fbaad 100644
--- a/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll
+++ b/llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll
@@ -3,110 +3,104 @@
declare void @use(i1)
-define void @loop_pointer_iv(i8* %start, i8* %end, i8* %upper) {
+define void @loop_pointer_iv(ptr %start, ptr %end, ptr %upper) {
; CHECK-LABEL: @loop_pointer_iv(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[END_LT_UPPER:%.*]] = icmp ult i8* [[END:%.*]], [[UPPER:%.*]]
+; CHECK-NEXT: [[END_LT_UPPER:%.*]] = icmp ult ptr [[END:%.*]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[END_LT_UPPER]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
; CHECK: loop.header:
-; CHECK-NEXT: [[IV:%.*]] = phi i8* [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
-; CHECK-NEXT: [[C_2:%.*]] = icmp ule i8* [[IV]], [[END]]
+; CHECK-NEXT: [[IV:%.*]] = phi ptr [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
+; CHECK-NEXT: [[C_2:%.*]] = icmp ule ptr [[IV]], [[END]]
; CHECK-NEXT: call void @use(i1 [[C_2]])
-; CHECK-NEXT: [[T_2:%.*]] = icmp uge i8* [[IV]], [[START]]
+; CHECK-NEXT: [[T_2:%.*]] = icmp uge ptr [[IV]], [[START]]
; CHECK-NEXT: call void @use(i1 [[T_2]])
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[IV]], [[END]]
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[IV]], [[END]]
; CHECK-NEXT: br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[T_1:%.*]] = icmp ult i8* [[IV]], [[UPPER]]
+; CHECK-NEXT: [[T_1:%.*]] = icmp ult ptr [[IV]], [[UPPER]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds i8, i8* [[IV]], i8 1
+; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds i8, ptr [[IV]], i8 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- %end.lt.upper = icmp ult i8* %end, %upper
+ %end.lt.upper = icmp ult ptr %end, %upper
br i1 %end.lt.upper, label %loop.header, label %exit
loop.header:
- %iv = phi i8* [ %start, %entry ], [ %iv.next, %loop.latch ]
- %c.2 = icmp ule i8* %iv, %end
+ %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop.latch ]
+ %c.2 = icmp ule ptr %iv, %end
call void @use(i1 %c.2)
-
- %t.2 = icmp uge i8* %iv, %start
+ %t.2 = icmp uge ptr %iv, %start
call void @use(i1 %t.2)
-
- %c.1 = icmp ule i8* %iv, %end
+ %c.1 = icmp ule ptr %iv, %end
br i1 %c.1, label %loop.latch, label %exit
loop.latch:
- %t.1 = icmp ult i8* %iv, %upper
+ %t.1 = icmp ult ptr %iv, %upper
call void @use(i1 %t.1)
-
- %iv.next = getelementptr inbounds i8, i8* %iv, i8 1
+ %iv.next = getelementptr inbounds i8, ptr %iv, i8 1
br label %loop.header
exit:
ret void
}
-define void @loop_pointer_iv_null_start(i8* %end, i8* %upper) {
+define void @loop_pointer_iv_null_start(ptr %end, ptr %upper) {
; CHECK-LABEL: @loop_pointer_iv_null_start(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[END_LT_UPPER:%.*]] = icmp ult i8* [[END:%.*]], [[UPPER:%.*]]
+; CHECK-NEXT: [[END_LT_UPPER:%.*]] = icmp ult ptr [[END:%.*]], [[UPPER:%.*]]
; CHECK-NEXT: br i1 [[END_LT_UPPER]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
; CHECK: loop.header:
-; CHECK-NEXT: [[IV:%.*]] = phi i8* [ null, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
-; CHECK-NEXT: [[C_1:%.*]] = icmp ule i8* [[IV]], [[END]]
+; CHECK-NEXT: [[IV:%.*]] = phi ptr [ null, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
+; CHECK-NEXT: [[C_1:%.*]] = icmp ule ptr [[IV]], [[END]]
; CHECK-NEXT: call void @use(i1 [[C_1]])
-; CHECK-NEXT: [[C_2:%.*]] = icmp uge i8* [[IV]], null
+; CHECK-NEXT: [[C_2:%.*]] = icmp uge ptr [[IV]], null
; CHECK-NEXT: call void @use(i1 [[C_2]])
-; CHECK-NEXT: [[C_3:%.*]] = icmp ule i8* [[IV]], [[END]]
+; CHECK-NEXT: [[C_3:%.*]] = icmp ule ptr [[IV]], [[END]]
; CHECK-NEXT: br i1 [[C_3]], label [[LOOP_LATCH]], label [[EXIT]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[C_4:%.*]] = icmp ult i8* [[IV]], [[UPPER]]
+; CHECK-NEXT: [[C_4:%.*]] = icmp ult ptr [[IV]], [[UPPER]]
; CHECK-NEXT: call void @use(i1 true)
-; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds i8, i8* [[IV]], i8 1
+; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds i8, ptr [[IV]], i8 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- %end.lt.upper = icmp ult i8* %end, %upper
+ %end.lt.upper = icmp ult ptr %end, %upper
br i1 %end.lt.upper, label %loop.header, label %exit
loop.header:
- %iv = phi i8* [ null, %entry ], [ %iv.next, %loop.latch ]
- %c.1 = icmp ule i8* %iv, %end
+ %iv = phi ptr [ null, %entry ], [ %iv.next, %loop.latch ]
+ %c.1 = icmp ule ptr %iv, %end
call void @use(i1 %c.1)
-
- %c.2 = icmp uge i8* %iv, null
+ %c.2 = icmp uge ptr %iv, null
call void @use(i1 %c.2)
-
- %c.3 = icmp ule i8* %iv, %end
+ %c.3 = icmp ule ptr %iv, %end
br i1 %c.3, label %loop.latch, label %exit
loop.latch:
- %c.4 = icmp ult i8* %iv, %upper
+ %c.4 = icmp ult ptr %iv, %upper
call void @use(i1 %c.4)
-
- %iv.next = getelementptr inbounds i8, i8* %iv, i8 1
+ %iv.next = getelementptr inbounds i8, ptr %iv, i8 1
br label %loop.header
exit:
ret void
}
-define void @test_start_null_cmp_null(i8* %start) {
+define void @test_start_null_cmp_null(ptr %start) {
; CHECK-LABEL: @test_start_null_cmp_null(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP_HEADER:%.*]]
; CHECK: loop.header:
-; CHECK-NEXT: [[IV:%.*]] = phi i8* [ null, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
-; CHECK-NEXT: [[CMP_I_I122:%.*]] = icmp eq i8* [[IV]], null
+; CHECK-NEXT: [[IV:%.*]] = phi ptr [ null, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
+; CHECK-NEXT: [[CMP_I_I122:%.*]] = icmp eq ptr [[IV]], null
; CHECK-NEXT: br i1 [[CMP_I_I122]], label [[LOOP_LATCH]], label [[EXIT:%.*]]
; CHECK: loop.latch:
-; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds i8, i8* [[IV]], i64 1
+; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds i8, ptr [[IV]], i64 1
; CHECK-NEXT: br label [[LOOP_HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret void
@@ -115,12 +109,12 @@ entry:
br label %loop.header
loop.header:
- %iv = phi i8* [ null, %entry ], [ %iv.next, %loop.latch ]
- %cmp.i.i122 = icmp eq i8* %iv, null
+ %iv = phi ptr [ null, %entry ], [ %iv.next, %loop.latch ]
+ %cmp.i.i122 = icmp eq ptr %iv, null
br i1 %cmp.i.i122, label %loop.latch, label %exit
loop.latch:
- %iv.next = getelementptr inbounds i8, i8* %iv, i64 1
+ %iv.next = getelementptr inbounds i8, ptr %iv, i64 1
br label %loop.header
exit:
diff --git a/llvm/test/Transforms/ConstraintElimination/ugt-ule.ll b/llvm/test/Transforms/ConstraintElimination/ugt-ule.ll
index f5e418a77c53d..80f58618adb7a 100644
--- a/llvm/test/Transforms/ConstraintElimination/ugt-ule.ll
+++ b/llvm/test/Transforms/ConstraintElimination/ugt-ule.ll
@@ -3,28 +3,28 @@
declare void @use(i1)
-define void @test(i8* %m, i8* %ptr) {
+define void @test(ptr %m, ptr %ptr) {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP_1:%.*]] = icmp ult i8* [[M:%.*]], [[PTR:%.*]]
+; CHECK-NEXT: [[CMP_1:%.*]] = icmp ult ptr [[M:%.*]], [[PTR:%.*]]
; CHECK-NEXT: br i1 [[CMP_1]], label [[BB_1:%.*]], label [[BB_2:%.*]]
; CHECK: bb.1:
-; CHECK-NEXT: [[CMP_2:%.*]] = icmp uge i8* [[M]], [[PTR]]
+; CHECK-NEXT: [[CMP_2:%.*]] = icmp uge ptr [[M]], [[PTR]]
; CHECK-NEXT: call void @use(i1 false)
; CHECK-NEXT: ret void
; CHECK: bb.2:
; CHECK-NEXT: br label [[BB_2_NEXT:%.*]]
; CHECK: bb.2.next:
-; CHECK-NEXT: [[CMP_3:%.*]] = icmp uge i8* [[M]], [[PTR]]
+; CHECK-NEXT: [[CMP_3:%.*]] = icmp uge ptr [[M]], [[PTR]]
; CHECK-NEXT: call void @use(i1 true)
; CHECK-NEXT: ret void
;
entry:
- %cmp.1 = icmp ult i8* %m, %ptr
+ %cmp.1 = icmp ult ptr %m, %ptr
br i1 %cmp.1, label %bb.1, label %bb.2
bb.1:
- %cmp.2 = icmp uge i8* %m, %ptr
+ %cmp.2 = icmp uge ptr %m, %ptr
call void @use(i1 %cmp.2)
ret void
@@ -32,7 +32,7 @@ bb.2:
br label %bb.2.next
bb.2.next:
- %cmp.3 = icmp uge i8* %m, %ptr
+ %cmp.3 = icmp uge ptr %m, %ptr
call void @use(i1 %cmp.3)
ret void
}
More information about the llvm-commits
mailing list