237 lines
7.0 KiB
LLVM
237 lines
7.0 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
|
; RUN: opt -S < %s -instcombine | FileCheck %s
|
|
|
|
;; Start by showing the results of constant folding (which doesn't use
|
|
;; the poison implied by gep for the nonnull cases).
|
|
|
|
define i1 @test_ne_constants_null() {
|
|
; CHECK-LABEL: @test_ne_constants_null(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: ret i1 false
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* null, i64 0
|
|
%cnd = icmp ne i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define i1 @test_ne_constants_nonnull() {
|
|
; CHECK-LABEL: @test_ne_constants_nonnull(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: ret i1 true
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* null, i64 1
|
|
%cnd = icmp ne i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define i1 @test_eq_constants_null() {
|
|
; CHECK-LABEL: @test_eq_constants_null(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: ret i1 true
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* null, i64 0
|
|
%cnd = icmp eq i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define i1 @test_eq_constants_nonnull() {
|
|
; CHECK-LABEL: @test_eq_constants_nonnull(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: ret i1 false
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* null, i64 1
|
|
%cnd = icmp eq i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
;; Then show the results for non-constants. These use the inbounds provided
|
|
;; UB fact to ignore the possible overflow cases.
|
|
|
|
define i1 @test_ne(i8* %base, i64 %idx) {
|
|
; CHECK-LABEL: @test_ne(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp ne i8* [[BASE:%.*]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* %base, i64 %idx
|
|
%cnd = icmp ne i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define i1 @test_eq(i8* %base, i64 %idx) {
|
|
; CHECK-LABEL: @test_eq(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp eq i8* [[BASE:%.*]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* %base, i64 %idx
|
|
%cnd = icmp eq i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define <2 x i1> @test_vector_base(<2 x i8*> %base, i64 %idx) {
|
|
; CHECK-LABEL: @test_vector_base(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp eq <2 x i8*> [[BASE:%.*]], zeroinitializer
|
|
; CHECK-NEXT: ret <2 x i1> [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, <2 x i8*> %base, i64 %idx
|
|
%cnd = icmp eq <2 x i8*> %gep, zeroinitializer
|
|
ret <2 x i1> %cnd
|
|
}
|
|
|
|
define <2 x i1> @test_vector_index(i8* %base, <2 x i64> %idx) {
|
|
; CHECK-LABEL: @test_vector_index(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i8*> poison, i8* [[BASE:%.*]], i64 0
|
|
; CHECK-NEXT: [[TMP0:%.*]] = icmp eq <2 x i8*> [[DOTSPLATINSERT]], zeroinitializer
|
|
; CHECK-NEXT: [[CND:%.*]] = shufflevector <2 x i1> [[TMP0]], <2 x i1> poison, <2 x i32> zeroinitializer
|
|
; CHECK-NEXT: ret <2 x i1> [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* %base, <2 x i64> %idx
|
|
%cnd = icmp eq <2 x i8*> %gep, zeroinitializer
|
|
ret <2 x i1> %cnd
|
|
}
|
|
|
|
define <2 x i1> @test_vector_both(<2 x i8*> %base, <2 x i64> %idx) {
|
|
; CHECK-LABEL: @test_vector_both(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp eq <2 x i8*> [[BASE:%.*]], zeroinitializer
|
|
; CHECK-NEXT: ret <2 x i1> [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, <2 x i8*> %base, <2 x i64> %idx
|
|
%cnd = icmp eq <2 x i8*> %gep, zeroinitializer
|
|
ret <2 x i1> %cnd
|
|
}
|
|
|
|
;; These two show instsimplify's reasoning getting to the non-zero offsets
|
|
;; before instcombine does.
|
|
|
|
define i1 @test_eq_pos_idx(i8* %base) {
|
|
; CHECK-LABEL: @test_eq_pos_idx(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: ret i1 false
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* %base, i64 1
|
|
%cnd = icmp eq i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define i1 @test_eq_neg_idx(i8* %base) {
|
|
; CHECK-LABEL: @test_eq_neg_idx(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: ret i1 false
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8* %base, i64 -1
|
|
%cnd = icmp eq i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
;; Show an example with a zero sized type since that's
|
|
;; a cornercase which keeps getting mentioned. The GEP
|
|
;; produces %base regardless of the value of the index
|
|
;; expression.
|
|
define i1 @test_size0({}* %base, i64 %idx) {
|
|
; CHECK-LABEL: @test_size0(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp ne {}* [[BASE:%.*]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds {}, {}* %base, i64 %idx
|
|
%cnd = icmp ne {}* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
define i1 @test_size0_nonzero_offset({}* %base) {
|
|
; CHECK-LABEL: @test_size0_nonzero_offset(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp ne {}* [[BASE:%.*]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds {}, {}* %base, i64 15
|
|
%cnd = icmp ne {}* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
|
|
define i1 @test_index_type([10 x i8]* %base, i64 %idx) {
|
|
; CHECK-LABEL: @test_index_type(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp eq [10 x i8]* [[BASE:%.*]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds [10 x i8], [10 x i8]* %base, i64 %idx, i64 %idx
|
|
%cnd = icmp eq i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
|
|
;; Finally, some negative tests for basic correctness checking.
|
|
|
|
define i1 @neq_noinbounds(i8* %base, i64 %idx) {
|
|
; CHECK-LABEL: @neq_noinbounds(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* [[BASE:%.*]], i64 [[IDX:%.*]]
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp ne i8* [[GEP]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr i8, i8* %base, i64 %idx
|
|
%cnd = icmp ne i8* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
define i1 @neg_objectatnull(i8 addrspace(2)* %base, i64 %idx) {
|
|
; CHECK-LABEL: @neg_objectatnull(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8 addrspace(2)* [[BASE:%.*]], i64 [[IDX:%.*]]
|
|
; CHECK-NEXT: [[CND:%.*]] = icmp eq i8 addrspace(2)* [[GEP]], null
|
|
; CHECK-NEXT: ret i1 [[CND]]
|
|
;
|
|
entry:
|
|
%gep = getelementptr inbounds i8, i8 addrspace(2)* %base, i64 %idx
|
|
%cnd = icmp eq i8 addrspace(2)* %gep, null
|
|
ret i1 %cnd
|
|
}
|
|
|
|
; Test for an assert from trying to create an invalid constantexpr
|
|
; bitcast between different address spaces. The addrspacecast is
|
|
; stripped off and the addrspace(0) null can be treated as invalid.
|
|
; FIXME: This should be able to fold to ret i1 false
|
|
define i1 @invalid_bitcast_icmp_addrspacecast_as0_null(i32 addrspace(5)* %ptr) {
|
|
; CHECK-LABEL: @invalid_bitcast_icmp_addrspacecast_as0_null(
|
|
; CHECK-NEXT: bb:
|
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 addrspace(5)* [[PTR:%.*]], addrspacecast (i32* null to i32 addrspace(5)*)
|
|
; CHECK-NEXT: ret i1 [[TMP2]]
|
|
;
|
|
bb:
|
|
%tmp1 = getelementptr inbounds i32, i32 addrspace(5)* %ptr, i32 1
|
|
%tmp2 = icmp eq i32 addrspace(5)* %tmp1, addrspacecast (i32* null to i32 addrspace(5)*)
|
|
ret i1 %tmp2
|
|
}
|
|
|
|
define i1 @invalid_bitcast_icmp_addrspacecast_as0_null_var(i32 addrspace(5)* %ptr, i32 %idx) {
|
|
; CHECK-LABEL: @invalid_bitcast_icmp_addrspacecast_as0_null_var(
|
|
; CHECK-NEXT: bb:
|
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 addrspace(5)* [[PTR:%.*]], addrspacecast (i32* null to i32 addrspace(5)*)
|
|
; CHECK-NEXT: ret i1 [[TMP2]]
|
|
;
|
|
bb:
|
|
%tmp1 = getelementptr inbounds i32, i32 addrspace(5)* %ptr, i32 %idx
|
|
%tmp2 = icmp eq i32 addrspace(5)* %tmp1, addrspacecast (i32* null to i32 addrspace(5)*)
|
|
ret i1 %tmp2
|
|
}
|