Test Failure: Transforms/InstCombine/vec_demanded_elts.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define i32 @test2(float %f) {
%0:
  %t5 = fmul float %f, %f
  %t9 = insertelement <4 x float> undef, float %t5, i32 0
  %t10 = insertelement <4 x float> %t9, float 0.000000, i32 1
  %t11 = insertelement <4 x float> %t10, float 0.000000, i32 2
  %t12 = insertelement <4 x float> %t11, float 0.000000, i32 3
  %t19 = bitcast <4 x float> %t12 to <4 x i32>
  %t21 = extractelement <4 x i32> %t19, i32 0
  ret i32 %t21
}
=>
define i32 @test2(float %f) {
%0:
  %t5 = fmul float %f, %f
  %t21 = bitcast float %t5 to i32
  ret i32 %t21
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @get_image() {
%entry:
  %0 = call i32 @fgetc(nocapture noundef * null) noundef nothrow
  %1 = trunc i32 %0 to i8
  %t2 = insertelement <100 x i8> { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, i8 %1, i32 1
  %t1 = extractelement <100 x i8> %t2, i32 0
  %2 = icmp eq i8 %t1, 80
  br i1 %2, label %bb2, label %bb3

%bb2:
  br label %bb3

%bb3:
  assume i1 0
}
=>
define void @get_image() {
%entry:
  %0 = call i32 @fgetc(nocapture noundef * null) noundef nothrow
  br i1 0, label %bb2, label %bb3

%bb2:
  br label %bb3

%bb3:
  assume i1 0
}
Transformation seems to be correct!


----------------------------------------
define void @vac(* nocapture %a) {
%entry:
  %t1 = load <4 x float>, * nocapture %a, align 16
  %vecins = insertelement <4 x float> %t1, float 0.000000, i32 0
  %vecins4 = insertelement <4 x float> %vecins, float 0.000000, i32 1
  %vecins6 = insertelement <4 x float> %vecins4, float 0.000000, i32 2
  %vecins8 = insertelement <4 x float> %vecins6, float 0.000000, i32 3
  store <4 x float> %vecins8, * nocapture %a, align 16
  ret void
}
=>
define void @vac(* nocapture %a) {
%entry:
  store <4 x float> { 0.000000, 0.000000, 0.000000, 0.000000 }, * nocapture %a, align 16
  ret void
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @dead_shuffle_elt(<4 x float> %x, <2 x float> %y) {
%0:
  %shuffle.i = shufflevector <2 x float> %y, <2 x float> %y, 0, 1, 0, 1
  %shuffle9.i = shufflevector <4 x float> %x, <4 x float> %shuffle.i, 4, 5, 2, 3
  ret <4 x float> %shuffle9.i
}
=>
define <4 x float> @dead_shuffle_elt(<4 x float> %x, <2 x float> %y) {
%0:
  %shuffle.i = shufflevector <2 x float> %y, <2 x float> undef, 0, 1, 4294967295, 4294967295
  %shuffle9.i = shufflevector <4 x float> %shuffle.i, <4 x float> %x, 0, 1, 6, 7
  ret <4 x float> %shuffle9.i
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @test_fptrunc(double %f) {
%0:
  %t9 = insertelement <4 x double> undef, double %f, i32 0
  %t10 = insertelement <4 x double> %t9, double 0.000000, i32 1
  %t11 = insertelement <4 x double> %t10, double 0.000000, i32 2
  %t12 = insertelement <4 x double> %t11, double 0.000000, i32 3
  %t5 = fptrunc <4 x double> %t12 to <4 x float>
  %ret = shufflevector <4 x float> %t5, <4 x float> undef, 0, 1
  ret <2 x float> %ret
}
=>
define <2 x float> @test_fptrunc(double %f) {
%0:
  %1 = insertelement <2 x double> { poison, 0.000000 }, double %f, i32 0
  %2 = fptrunc <2 x double> %1 to <2 x float>
  ret <2 x float> %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x double> @test_fpext(float %f) {
%0:
  %t9 = insertelement <4 x float> undef, float %f, i32 0
  %t10 = insertelement <4 x float> %t9, float 0.000000, i32 1
  %t11 = insertelement <4 x float> %t10, float 0.000000, i32 2
  %t12 = insertelement <4 x float> %t11, float 0.000000, i32 3
  %t5 = fpext <4 x float> %t12 to <4 x double>
  %ret = shufflevector <4 x double> %t5, <4 x double> undef, 0, 1
  ret <2 x double> %ret
}
=>
define <2 x double> @test_fpext(float %f) {
%0:
  %1 = insertelement <2 x float> { poison, 0.000000 }, float %f, i32 0
  %2 = fpext <2 x float> %1 to <2 x double>
  ret <2 x double> %2
}
Transformation seems to be correct!


----------------------------------------
define <4 x double> @test_shuffle(<4 x double> %f) {
%0:
  %ret = shufflevector <4 x double> %f, <4 x double> { undef, 1.000000, undef, undef }, 0, 1, 2, 5
  ret <4 x double> %ret
}
=>
define <4 x double> @test_shuffle(<4 x double> %f) {
%0:
  %ret1 = insertelement <4 x double> %f, double 1.000000, i32 3
  ret <4 x double> %ret1
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @test_select(float %f, float %g) {
%0:
  %a0 = insertelement <4 x float> undef, float %f, i32 0
  %a1 = insertelement <4 x float> %a0, float 1.000000, i32 1
  %a2 = insertelement <4 x float> %a1, float 2.000000, i32 2
  %a3 = insertelement <4 x float> %a2, float 3.000000, i32 3
  %b0 = insertelement <4 x float> undef, float %g, i32 0
  %b1 = insertelement <4 x float> %b0, float 4.000000, i32 1
  %b2 = insertelement <4 x float> %b1, float 5.000000, i32 2
  %b3 = insertelement <4 x float> %b2, float 6.000000, i32 3
  %ret = select <4 x i1> { 1, 0, 0, 1 }, <4 x float> %a3, <4 x float> %b3
  ret <4 x float> %ret
}
=>
define <4 x float> @test_select(float %f, float %g) {
%0:
  %a3 = insertelement <4 x float> { poison, poison, poison, 3.000000 }, float %f, i32 0
  %ret = shufflevector <4 x float> %a3, <4 x float> { poison, 4.000000, 5.000000, poison }, 0, 5, 6, 3
  ret <4 x float> %ret
}
Transformation seems to be correct!


----------------------------------------
define <2 x i64> @PR24922(<2 x i64> %v) {
%0:
  %__constexpr_2 = bitcast <4 x i32> { 15, 15, 15, 15 } to <2 x i64>
  %__constexpr_1 = extractelement <2 x i64> %__constexpr_2, i64 0
  %__constexpr_0 = icmp eq i64 %__constexpr_1, 0
  %__copy_0 = <2 x i1> { %__constexpr_0, 1 }
  %result = select <2 x i1> %__copy_0, <2 x i64> %v, <2 x i64> { 0, 0 }
  ret <2 x i64> %result
}
=>
define <2 x i64> @PR24922(<2 x i64> %v) {
%0:
  %result1 = insertelement <2 x i64> %v, i64 0, i32 0
  ret <2 x i64> %result1
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @inselt_shuf_no_demand(float %a1, float %a2, float %a3) {
%0:
  %out1 = insertelement <4 x float> undef, float %a1, i32 1
  %out12 = insertelement <4 x float> %out1, float %a2, i32 2
  %out123 = insertelement <4 x float> %out12, float %a3, i32 3
  %shuffle = shufflevector <4 x float> %out123, <4 x float> undef, 0, 4294967295, 4294967295, 4294967295
  ret <4 x float> %shuffle
}
=>
define <4 x float> @inselt_shuf_no_demand(float %a1, float %a2, float %a3) {
%0:
  ret <4 x float> undef
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x float> @inselt_shuf_no_demand_commute(float %a1, float %a2, float %a3) {
%0:
  %out1 = insertelement <4 x float> undef, float %a1, i32 1
  %out12 = insertelement <4 x float> %out1, float %a2, i32 2
  %out123 = insertelement <4 x float> %out12, float %a3, i32 3
  %shuffle = shufflevector <4 x float> undef, <4 x float> %out123, 4, 4294967295, 4294967295, 4294967295
  ret <4 x float> %shuffle
}
=>
define <4 x float> @inselt_shuf_no_demand_commute(float %a1, float %a2, float %a3) {
%0:
  ret <4 x float> undef
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x i32> @inselt_shuf_no_demand_multiuse(i32 %a0, i32 %a1, <4 x i32> %b) {
%0:
  %out0 = insertelement <4 x i32> undef, i32 %a0, i32 0
  %out01 = insertelement <4 x i32> %out0, i32 %a1, i32 1
  %out012 = insertelement <4 x i32> %out01, i32 %a0, i32 2
  %foo = add <4 x i32> %out012, %b
  %out0123 = insertelement <4 x i32> %foo, i32 %a1, i32 3
  %shuffle = shufflevector <4 x i32> %out0123, <4 x i32> undef, 0, 1, 4294967295, 4294967295
  ret <4 x i32> %shuffle
}
=>
define <4 x i32> @inselt_shuf_no_demand_multiuse(i32 %a0, i32 %a1, <4 x i32> %b) {
%0:
  %out0 = insertelement <4 x i32> undef, i32 %a0, i32 0
  %out01 = insertelement <4 x i32> %out0, i32 %a1, i32 1
  %foo = add <4 x i32> %out01, %b
  %shuffle = shufflevector <4 x i32> %foo, <4 x i32> undef, 0, 1, 4294967295, 4294967295
  ret <4 x i32> %shuffle
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x float> @inselt_shuf_no_demand_bogus_insert_index_in_chain(float %a1, float %a2, float %a3, i32 %variable_index) {
%0:
  %out1 = insertelement <4 x float> undef, float %a1, i32 1
  %out12 = insertelement <4 x float> %out1, float %a2, i32 %variable_index
  %out123 = insertelement <4 x float> %out12, float %a3, i32 3
  %shuffle = shufflevector <4 x float> %out123, <4 x float> undef, 0, 4294967295, 4294967295, 4294967295
  ret <4 x float> %shuffle
}
=>
define <4 x float> @inselt_shuf_no_demand_bogus_insert_index_in_chain(float %a1, float %a2, float %a3, i32 %variable_index) {
%0:
  %out12 = insertelement <4 x float> undef, float %a2, i32 %variable_index
  %shuffle = shufflevector <4 x float> %out12, <4 x float> undef, 0, 4294967295, 4294967295, 4294967295
  ret <4 x float> %shuffle
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <3 x i8> @shuf_add(<3 x i8> %x) {
%0:
  %bo = add nsw <3 x i8> %x, { 1, 2, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 4294967295, 2
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_add(<3 x i8> %x) {
%0:
  %bo = add <3 x i8> %x, { poison, 2, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 4294967295, 2
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x i8> @shuf_sub(<3 x i8> %x) {
%0:
  %bo = sub nuw <3 x i8> { 1, 2, 3 }, %x
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 0, 4294967295, 2
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_sub(<3 x i8> %x) {
%0:
  %bo = sub <3 x i8> { 1, poison, 3 }, %x
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 0, 4294967295, 2
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x i8> @shuf_mul(<3 x i8> %x) {
%0:
  %bo = mul nsw <3 x i8> %x, { 1, 2, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 0, 2, 0
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_mul(<3 x i8> %x) {
%0:
  %bo = mul <3 x i8> %x, { 1, poison, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 0, 2, 0
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x i8> @shuf_and(<3 x i8> %x) {
%0:
  %bo = and <3 x i8> %x, { 1, 2, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 1, 0
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_and(<3 x i8> %x) {
%0:
  %bo = and <3 x i8> %x, { 1, 2, poison }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 1, 0
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x i8> @shuf_or(<3 x i8> %x) {
%0:
  %bo = or <3 x i8> %x, { 1, 2, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 4294967295, 0
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_or(<3 x i8> %x) {
%0:
  %bo = or <3 x i8> %x, { 1, 2, poison }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 4294967295, 0
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x i8> @shuf_xor(<3 x i8> %x) {
%0:
  %bo = xor <3 x i8> %x, { 1, 2, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 4294967295, 0
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_xor(<3 x i8> %x) {
%0:
  %bo = xor <3 x i8> %x, { 1, poison, 3 }
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 4294967295, 0
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x i8> @shuf_ashr_const_op0(<3 x i8> %x) {
%0:
  %bo = ashr <3 x i8> { 1, 2, 3 }, %x
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 0, 4294967295, 1
  ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_ashr_const_op0(<3 x i8> %x) {
%0:
  %bo = lshr <3 x i8> { 1, 2, 3 }, %x
  %r = shufflevector <3 x i8> %bo, <3 x i8> undef, 0, 4294967295, 1
  ret <3 x i8> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x float> @shuf_fadd(<3 x float> %x) {
%0:
  %bo = fadd <3 x float> %x, { 1.000000, 2.000000, 3.000000 }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_fadd(<3 x float> %x) {
%0:
  %bo = fadd <3 x float> %x, { 1.000000, 2.000000, poison }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
  ret <3 x float> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x float> @shuf_fsub(<3 x float> %x) {
%0:
  %bo = fsub fast <3 x float> { 1.000000, 2.000000, 3.000000 }, %x
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 0, 2
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_fsub(<3 x float> %x) {
%0:
  %bo = fsub fast <3 x float> { 1.000000, poison, 3.000000 }, %x
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 0, 2
  ret <3 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <3 x float> @shuf_fmul(<3 x float> %x) {
%0:
  %bo = fmul reassoc <3 x float> %x, { 1.000000, 2.000000, 3.000000 }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_fmul(<3 x float> %x) {
%0:
  %bo = fmul reassoc <3 x float> %x, { 1.000000, 2.000000, poison }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
  ret <3 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <3 x float> @shuf_fdiv_const_op0(<3 x float> %x) {
%0:
  %bo = fdiv ninf reassoc <3 x float> { 1.000000, 2.000000, 3.000000 }, %x
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 0, 2
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_fdiv_const_op0(<3 x float> %x) {
%0:
  %bo = fdiv ninf reassoc <3 x float> { 1.000000, poison, 3.000000 }, %x
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 0, 2
  ret <3 x float> %r
}
Transformation seems to be correct!


----------------------------------------
define <3 x float> @shuf_fdiv_const_op1(<3 x float> %x) {
%0:
  %bo = fdiv nnan ninf <3 x float> %x, { 1.000000, 2.000000, 3.000000 }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_fdiv_const_op1(<3 x float> %x) {
%0:
  %bo = fdiv nnan ninf <3 x float> %x, { 1.000000, 2.000000, poison }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
  ret <3 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <3 x float> @shuf_frem_const_op0(<3 x float> %x) {
%0:
  %bo = frem nnan <3 x float> { 1.000000, 2.000000, 3.000000 }, %x
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 2, 0
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_frem_const_op0(<3 x float> %x) {
%0:
  %bo = frem nnan <3 x float> { 1.000000, poison, 3.000000 }, %x
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 2, 0
  ret <3 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <3 x float> @shuf_frem_const_op1(<3 x float> %x) {
%0:
  %bo = frem ninf reassoc <3 x float> %x, { 1.000000, 2.000000, 3.000000 }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 1, 4294967295, 2
  ret <3 x float> %r
}
=>
define <3 x float> @shuf_frem_const_op1(<3 x float> %x) {
%0:
  %bo = frem ninf reassoc <3 x float> %x, { poison, 2.000000, 3.000000 }
  %r = shufflevector <3 x float> %bo, <3 x float> undef, 1, 4294967295, 2
  ret <3 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define * @gep_splat_base_w_s_idx(* %base) {
%0:
  %basevec1 = insertelement <2 x *> undef, * %base, i32 0
  %basevec2 = shufflevector <2 x *> %basevec1, <2 x *> undef, 0, 0
  %gep = gep <2 x *> %basevec2, 4 x i64 1
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
define * @gep_splat_base_w_s_idx(* %base) {
%0:
  %basevec2 = insertelement <2 x *> undef, * %base, i32 1
  %gep = gep <2 x *> %basevec2, 4 x i64 1
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
define * @gep_splat_base_w_cv_idx(* %base) {
%0:
  %basevec1 = insertelement <2 x *> undef, * %base, i32 0
  %basevec2 = shufflevector <2 x *> %basevec1, <2 x *> undef, 0, 0
  %gep = gep <2 x *> %basevec2, 4 x <2 x i64> { 0, 1 }
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
define * @gep_splat_base_w_cv_idx(* %base) {
%0:
  %basevec2 = insertelement <2 x *> undef, * %base, i32 1
  %gep = gep <2 x *> %basevec2, 4 x <2 x i64> { poison, 1 }
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
define * @gep_splat_base_w_vidx(* %base, <2 x i64> %idxvec) {
%0:
  %basevec1 = insertelement <2 x *> undef, * %base, i32 0
  %basevec2 = shufflevector <2 x *> %basevec1, <2 x *> undef, 0, 0
  %gep = gep <2 x *> %basevec2, 4 x <2 x i64> %idxvec
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
define * @gep_splat_base_w_vidx(* %base, <2 x i64> %idxvec) {
%0:
  %basevec2 = insertelement <2 x *> undef, * %base, i32 1
  %gep = gep <2 x *> %basevec2, 4 x <2 x i64> %idxvec
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
@GLOBAL = global 4 bytes, align 4

define * @gep_cvbase_w_s_idx(<2 x *> %base, i64 %raw_addr) {
%0:
  %__copy_0 = <2 x *> { @GLOBAL, @GLOBAL }
  %gep = gep <2 x *> %__copy_0, 4 x i64 %raw_addr
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
@GLOBAL = global 4 bytes, align 4

define * @gep_cvbase_w_s_idx(<2 x *> %base, i64 %raw_addr) {
%0:
  %__copy_0 = <2 x *> { poison, @GLOBAL }
  %gep = gep <2 x *> %__copy_0, 4 x i64 %raw_addr
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
@GLOBAL = global 4 bytes, align 4

define * @gep_cvbase_w_cv_idx(<2 x *> %base, i64 %raw_addr) {
%0:
  %__copy_0 = <2 x *> { @GLOBAL, @GLOBAL }
  %gep = gep <2 x *> %__copy_0, 4 x <2 x i64> { 0, 1 }
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
@GLOBAL = global 4 bytes, align 4

define * @gep_cvbase_w_cv_idx(<2 x *> %base, i64 %raw_addr) {
%0:
  %__constexpr_0 = gep inbounds * @GLOBAL, 4 x i64 1
  ret * %__constexpr_0
}
Transformation seems to be correct!


----------------------------------------
define * @gep_sbase_w_cv_idx(* %base) {
%0:
  %gep = gep * %base, 4 x <2 x i64> { 0, 1 }
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
define * @gep_sbase_w_cv_idx(* %base) {
%0:
  %gep = gep * %base, 4 x <2 x i64> { poison, 1 }
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
define * @gep_sbase_w_splat_idx(* %base, i64 %idx) {
%0:
  %idxvec1 = insertelement <2 x i64> undef, i64 %idx, i32 0
  %idxvec2 = shufflevector <2 x i64> %idxvec1, <2 x i64> undef, 0, 0
  %gep = gep * %base, 4 x <2 x i64> %idxvec2
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
define * @gep_sbase_w_splat_idx(* %base, i64 %idx) {
%0:
  %idxvec2 = insertelement <2 x i64> undef, i64 %idx, i32 1
  %gep = gep * %base, 4 x <2 x i64> %idxvec2
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
define * @gep_splat_both(* %base, i64 %idx) {
%0:
  %basevec1 = insertelement <2 x *> undef, * %base, i32 0
  %basevec2 = shufflevector <2 x *> %basevec1, <2 x *> undef, 0, 0
  %idxvec1 = insertelement <2 x i64> undef, i64 %idx, i32 0
  %idxvec2 = shufflevector <2 x i64> %idxvec1, <2 x i64> undef, 0, 0
  %gep = gep <2 x *> %basevec2, 4 x <2 x i64> %idxvec2
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
=>
define * @gep_splat_both(* %base, i64 %idx) {
%0:
  %basevec2 = insertelement <2 x *> undef, * %base, i32 1
  %idxvec2 = insertelement <2 x i64> undef, i64 %idx, i32 1
  %gep = gep <2 x *> %basevec2, 4 x <2 x i64> %idxvec2
  %ee = extractelement <2 x *> %gep, i32 1
  ret * %ee
}
Transformation seems to be correct!


----------------------------------------
define <2 x *> @gep_all_lanes_undef(* %base, i64 %idx) {
%0:
  %basevec = insertelement <2 x *> undef, * %base, i32 0
  %idxvec = insertelement <2 x i64> undef, i64 %idx, i32 1
  %gep = gep <2 x *> %basevec, 4 x <2 x i64> %idxvec
  ret <2 x *> %gep
}
=>
define <2 x *> @gep_all_lanes_undef(* %base, i64 %idx) {
%0:
  ret <2 x *> undef
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
* %base = pointer(non-local, block_id=1, offset=0)
i64 %idx = poison

Source:
<2 x *> %basevec = < pointer(non-local, block_id=1, offset=0), null >
<2 x i64> %idxvec = < any, poison >
<2 x *> %gep = < pointer(non-local, block_id=1, offset=0)	[based on undef value], poison >

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0
Block 1 >	size: 0	align: 2	alloc type: 0

Target:
Source value: < pointer(non-local, block_id=1, offset=0), poison >
Target value: < pointer(non-local, block_id=0, offset=268435456), pointer(non-local, block_id=0, offset=18014398509481984) >


------------------- SMT STATS -------------------
Num queries: 116
Num invalid: 0
Num skips:   0
Num trivial: 128 (52.5%)
Num timeout: 11 (9.5%)
Num errors:  0 (0.0%)
Num SAT:     38 (32.8%)
Num UNSAT:   67 (57.8%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -instcombine -S
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll

<-- Back