maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[ConstraintElimination] Update tests to use opaque pointers.

This commit is contained in:
Florian Hahn 2022-10-06 18:07:25 +01:00
parent da594649fe
commit c5e1ddb6fd
No known key found for this signature in database
GPG Key ID: EEF712BB5E80EBBA
13 changed files with 1566 additions and 1652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
llvm/test/Transforms/ConstraintElimination/and.ll
View File

@ -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

588
llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll
View File

File diff suppressed because it is too large Load Diff

166
llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll
View File

@ -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
}

395
llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll
View File

@ -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
}

614
llvm/test/Transforms/ConstraintElimination/geps-signed-predicates.ll
View File

@ -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
}

614
llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll
View File

@ -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
}

15
llvm/test/Transforms/ConstraintElimination/invoke.ll
View File

@ -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

90
llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll
View File

@ -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:

54
llvm/test/Transforms/ConstraintElimination/large-system-growth.ll
View File

@ -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
}

116
llvm/test/Transforms/ConstraintElimination/loops-bottom-tested-pointer-cmps.ll
View File

@ -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

454
llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll
View File

@ -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

80
llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll
View File

@ -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:

14
llvm/test/Transforms/ConstraintElimination/ugt-ule.ll
View File

@ -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
}