Test source: git
Source: <stdin>
----------------------------------------
define i32 @test2(float %f) {
%0:
%tmp5 = fmul float %f, %f
%tmp9 = insertelement <4 x float> undef, float %tmp5, i32 0
%tmp10 = insertelement <4 x float> %tmp9, float 0.000000, i32 1
%tmp11 = insertelement <4 x float> %tmp10, float 0.000000, i32 2
%tmp12 = insertelement <4 x float> %tmp11, float 0.000000, i32 3
%tmp19 = bitcast <4 x float> %tmp12 to <4 x i32>
%tmp21 = extractelement <4 x i32> %tmp19, i32 0
ret i32 %tmp21
}
=>
define i32 @test2(float %f) {
%0:
%tmp5 = fmul float %f, %f
%tmp21 = bitcast float %tmp5 to i32
ret i32 %tmp21
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define void @get_image() {
%entry:
%0 = call i32 @fgetc(* null) ; WARNING: unknown known function
%1 = trunc i32 %0 to i8
%tmp2 = 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
%tmp1 = extractelement <100 x i8> %tmp2, i32 0
%2 = icmp eq i8 %tmp1, 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(* null) ; WARNING: unknown known function
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:
%tmp1 = load <4 x float>, * nocapture %a, align 16
%vecins = insertelement <4 x float> %tmp1, 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:
%tmp9 = insertelement <4 x double> undef, double %f, i32 0
%tmp10 = insertelement <4 x double> %tmp9, double 0.000000, i32 1
%tmp11 = insertelement <4 x double> %tmp10, double 0.000000, i32 2
%tmp12 = insertelement <4 x double> %tmp11, double 0.000000, i32 3
%tmp5 = fptrunc <4 x double> %tmp12 to <4 x float>
%ret = shufflevector <4 x float> %tmp5, <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> { undef, 0.000000 }, double %f, i32 0
%2 = fptrunc <2 x double> %1 to <2 x float>
ret <2 x float> %2
}
Transformation seems to be correct!
----------------------------------------
define <2 x double> @test_fpext(float %f) {
%0:
%tmp9 = insertelement <4 x float> undef, float %f, i32 0
%tmp10 = insertelement <4 x float> %tmp9, float 0.000000, i32 1
%tmp11 = insertelement <4 x float> %tmp10, float 0.000000, i32 2
%tmp12 = insertelement <4 x float> %tmp11, float 0.000000, i32 3
%tmp5 = fpext <4 x float> %tmp12 to <4 x double>
%ret = shufflevector <4 x double> %tmp5, <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> { undef, 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> { undef, undef, undef, 3.000000 }, float %f, i32 0
%ret = shufflevector <4 x float> %a3, <4 x float> { undef, 4.000000, 5.000000, undef }, 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 seems to be correct!
----------------------------------------
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 seems to be correct!
----------------------------------------
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, { undef, 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, undef, 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, undef, 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, undef }
%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, undef }
%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, undef, 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_lshr_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, 2, 1, 4294967295
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_lshr_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, 2, 1, 4294967295
ret <3 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <3 x i8> @shuf_lshr_const_op1(<3 x i8> %x) {
%0:
%bo = lshr exact <3 x i8> %x, { 1, 2, 3 }
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 1, 4294967295
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_lshr_const_op1(<3 x i8> %x) {
%0:
%bo = lshr exact <3 x i8> %x, { 1, 2, 3 }
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 1, 4294967295
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 i8> @shuf_ashr_const_op1(<3 x i8> %x) {
%0:
%bo = ashr exact <3 x i8> %x, { 1, 2, 3 }
%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_op1(<3 x i8> %x) {
%0:
%bo = ashr exact <3 x i8> %x, { 1, 2, 3 }
%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 i8> @shuf_shl_const_op0(<3 x i8> %x) {
%0:
%bo = shl nsw <3 x i8> { 1, 2, 3 }, %x
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 4294967295, 0
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_shl_const_op0(<3 x i8> %x) {
%0:
%bo = shl nsw <3 x i8> { 1, 2, 3 }, %x
%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_shl_const_op1(<3 x i8> %x) {
%0:
%bo = shl nuw <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_shl_const_op1(<3 x i8> %x) {
%0:
%bo = shl nuw <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
}
Transformation seems to be correct!
----------------------------------------
define <3 x i8> @shuf_sdiv_const_op0(<3 x i8> %x) {
%0:
%bo = sdiv exact <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_sdiv_const_op0(<3 x i8> %x) {
%0:
%bo = sdiv exact <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 i8> @shuf_sdiv_const_op1(<3 x i8> %x) {
%0:
%bo = sdiv <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_sdiv_const_op1(<3 x i8> %x) {
%0:
%bo = sdiv <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
}
Transformation seems to be correct!
----------------------------------------
define <3 x i8> @shuf_srem_const_op0(<3 x i8> %x) {
%0:
%bo = srem <3 x i8> { 1, 2, 3 }, %x
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 1, 4294967295, 2
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_srem_const_op0(<3 x i8> %x) {
%0:
%bo = srem <3 x i8> { 1, 2, 3 }, %x
%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_srem_const_op1(<3 x i8> %x) {
%0:
%bo = srem <3 x i8> %x, { 1, 2, 3 }
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 4294967295, 1
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_srem_const_op1(<3 x i8> %x) {
%0:
%bo = srem <3 x i8> %x, { 1, 2, 3 }
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 4294967295, 1
ret <3 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <3 x i8> @shuf_udiv_const_op0(<3 x i8> %x) {
%0:
%bo = udiv exact <3 x i8> { 1, 2, 3 }, %x
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 4294967295, 0
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_udiv_const_op0(<3 x i8> %x) {
%0:
%bo = udiv exact <3 x i8> { 1, 2, 3 }, %x
%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_udiv_const_op1(<3 x i8> %x) {
%0:
%bo = udiv <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_udiv_const_op1(<3 x i8> %x) {
%0:
%bo = udiv <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
}
Transformation seems to be correct!
----------------------------------------
define <3 x i8> @shuf_urem_const_op0(<3 x i8> %x) {
%0:
%bo = urem <3 x i8> { 1, 2, 3 }, %x
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 1, 4294967295
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_urem_const_op0(<3 x i8> %x) {
%0:
%bo = urem <3 x i8> { 1, 2, 3 }, %x
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 2, 1, 4294967295
ret <3 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <3 x i8> @shuf_urem_const_op1(<3 x i8> %x) {
%0:
%bo = urem <3 x i8> %x, { 1, 2, 3 }
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 4294967295, 1, 0
ret <3 x i8> %r
}
=>
define <3 x i8> @shuf_urem_const_op1(<3 x i8> %x) {
%0:
%bo = urem <3 x i8> %x, { 1, 2, 3 }
%r = shufflevector <3 x i8> %bo, <3 x i8> undef, 4294967295, 1, 0
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, undef }
%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, undef, 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: Invalid expr
----------------------------------------
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, undef }
%r = shufflevector <3 x float> %bo, <3 x float> undef, 4294967295, 1, 0
ret <3 x float> %r
}
Transformation doesn't verify!
ERROR: Invalid expr
----------------------------------------
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, undef, 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: Invalid expr
----------------------------------------
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, undef }
%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_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, undef, 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: Invalid expr
----------------------------------------
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, { undef, 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: Invalid expr
----------------------------------------
define * @gep_vbase_w_s_idx(<2 x *> %base) {
%0:
%gep = gep <2 x *> %base, 4 x i64 1
%ee = extractelement <2 x *> %gep, i32 1
ret * %ee
}
=>
define * @gep_vbase_w_s_idx(<2 x *> %base) {
%0:
%gep = gep <2 x *> %base, 4 x i64 1
%ee = extractelement <2 x *> %gep, i32 1
ret * %ee
}
Transformation seems to be correct!
----------------------------------------
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> { undef, 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 *> { undef, @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> { undef, 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 doesn't verify!
ERROR: Timeout
----------------------------------------
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=0, offset=-9151314442816847871)
i64 %idx = undef
Source:
<2 x *> %basevec = < pointer(non-local, block_id=0, offset=-9151314442816847871), null >
<2 x i64> %idxvec = < undef, undef >
<2 x *> %gep = < pointer(non-local, block_id=0, offset=-9151314442816847871) [based on undef value], null [based on undef value] >
SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 > size: 0 align: 64 alloc type: 0
Block 1 > size: 0 align: 2 alloc type: 0
Target:
Source value: < pointer(non-local, block_id=0, offset=-9151314442816847871), null >
Target value: < null, null >
------------------- SMT STATS -------------------
Num queries: 113
Num invalid: 5
Num skips: 0
Num trivial: 121 (51.7%)
Num timeout: 4 (3.5%)
Num errors: 0 (0.0%)
Num SAT: 53 (46.9%)
Num UNSAT: 56 (49.6%)
+ : 'RUN: at line 2' + /home/nlopes/alive2/scripts/opt-alive.sh -instcombine -S + /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll Alive2: Transform doesn't verify; aborting! 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