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 }