Test Failure: Transforms/InstCombine/vector-casts.ll

Test source: git

Log:

Source: <stdin>
ERROR: Unsupported type: <vscale x 4 x float>

----------------------------------------
define <2 x i1> @trunc(<2 x i64> %a) {
%0:
  %t = trunc <2 x i64> %a to <2 x i1>
  ret <2 x i1> %t
}
=>
define <2 x i1> @trunc(<2 x i64> %a) {
%0:
  %t = trunc <2 x i64> %a to <2 x i1>
  ret <2 x i1> %t
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i1> @and_cmp_is_trunc(<2 x i64> %a) {
%0:
  %t = and <2 x i64> %a, { 1, 1 }
  %r = icmp ne <2 x i64> %t, { 0, 0 }
  ret <2 x i1> %r
}
=>
define <2 x i1> @and_cmp_is_trunc(<2 x i64> %a) {
%0:
  %r = trunc <2 x i64> %a to <2 x i1>
  ret <2 x i1> %r
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @and_cmp_is_trunc_even_with_undef_elt(<2 x i64> %a) {
%0:
  %t = and <2 x i64> %a, { undef, 1 }
  %r = icmp ne <2 x i64> %t, { 0, 0 }
  ret <2 x i1> %r
}
=>
define <2 x i1> @and_cmp_is_trunc_even_with_undef_elt(<2 x i64> %a) {
%0:
  %r = trunc <2 x i64> %a to <2 x i1>
  ret <2 x i1> %r
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @and_cmp_is_trunc_even_with_undef_elts(<2 x i64> %a) {
%0:
  %t = and <2 x i64> %a, { undef, 1 }
  %r = icmp ne <2 x i64> %t, { undef, 0 }
  ret <2 x i1> %r
}
=>
define <2 x i1> @and_cmp_is_trunc_even_with_undef_elts(<2 x i64> %a) {
%0:
  %t = and <2 x i64> %a, { undef, 1 }
  %r = icmp ne <2 x i64> %t, { undef, 0 }
  ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i64> @test2(<2 x i64> %a) {
%0:
  %b = and <2 x i64> %a, { 65535, 65535 }
  %t = ashr <2 x i64> %b, { 1, 1 }
  ret <2 x i64> %t
}
=>
define <2 x i64> @test2(<2 x i64> %a) {
%0:
  %b = lshr <2 x i64> %a, { 1, 1 }
  %1 = and <2 x i64> %b, { 32767, 32767 }
  ret <2 x i64> %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @test3(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ord <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext = sext <4 x i1> %cmp to <4 x i32>
  %cmp4 = fcmp ord <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext5 = sext <4 x i1> %cmp4 to <4 x i32>
  %and = and <4 x i32> %sext, %sext5
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
=>
define <2 x i64> @test3(<4 x float> %a, <4 x float> %b) {
%0:
  %1 = fcmp ord <4 x float> %a, %b
  %and = sext <4 x i1> %1 to <4 x i32>
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @test4(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp uno <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext = sext <4 x i1> %cmp to <4 x i32>
  %cmp4 = fcmp uno <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext5 = sext <4 x i1> %cmp4 to <4 x i32>
  %or = or <4 x i32> %sext, %sext5
  %conv = bitcast <4 x i32> %or to <2 x i64>
  ret <2 x i64> %conv
}
=>
define <2 x i64> @test4(<4 x float> %a, <4 x float> %b) {
%0:
  %1 = fcmp uno <4 x float> %a, %b
  %or = sext <4 x i1> %1 to <4 x i32>
  %conv = bitcast <4 x i32> %or to <2 x i64>
  ret <2 x i64> %conv
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @test5(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ult <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext = sext <4 x i1> %cmp to <4 x i32>
  %cmp4 = fcmp ult <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext5 = sext <4 x i1> %cmp4 to <4 x i32>
  %and = and <4 x i32> %sext, %sext5
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
=>
define <2 x i64> @test5(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ult <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %cmp4 = fcmp ult <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %and1 = and <4 x i1> %cmp, %cmp4
  %and = sext <4 x i1> %and1 to <4 x i32>
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @test6(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ult <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext = sext <4 x i1> %cmp to <4 x i32>
  %cmp4 = fcmp ult <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext5 = sext <4 x i1> %cmp4 to <4 x i32>
  %and = or <4 x i32> %sext, %sext5
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
=>
define <2 x i64> @test6(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ult <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %cmp4 = fcmp ult <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %and1 = or <4 x i1> %cmp, %cmp4
  %and = sext <4 x i1> %and1 to <4 x i32>
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @test7(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ult <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext = sext <4 x i1> %cmp to <4 x i32>
  %cmp4 = fcmp ult <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %sext5 = sext <4 x i1> %cmp4 to <4 x i32>
  %and = xor <4 x i32> %sext, %sext5
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
=>
define <2 x i64> @test7(<4 x float> %a, <4 x float> %b) {
%0:
  %cmp = fcmp ult <4 x float> %a, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %cmp4 = fcmp ult <4 x float> %b, { 0.000000, 0.000000, 0.000000, 0.000000 }
  %and1 = xor <4 x i1> %cmp, %cmp4
  %and = sext <4 x i1> %and1 to <4 x i32>
  %conv = bitcast <4 x i32> %and to <2 x i64>
  ret <2 x i64> %conv
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @convert(* %dst.addr, <2 x i64> %src) {
%0:
  %val = trunc <2 x i64> %src to <2 x i32>
  %add = add <2 x i32> %val, { 1, 1 }
  store <2 x i32> %add, * %dst.addr, align 8
  ret void
}
=>
define void @convert(* %dst.addr, <2 x i64> %src) {
%0:
  %val = trunc <2 x i64> %src to <2 x i32>
  %add = add <2 x i32> %val, { 1, 1 }
  store <2 x i32> %add, * %dst.addr, align 8
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i65> @foo(<2 x i64> %t) {
%0:
  %a = trunc <2 x i64> %t to <2 x i32>
  %b = zext <2 x i32> %a to <2 x i65>
  ret <2 x i65> %b
}
=>
define <2 x i65> @foo(<2 x i64> %t) {
%0:
  %a.mask = and <2 x i64> %t, { 4294967295, 4294967295 }
  %b = zext <2 x i64> %a.mask to <2 x i65>
  ret <2 x i65> %b
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @bar(<2 x i65> %t) {
%0:
  %a = trunc <2 x i65> %t to <2 x i32>
  %b = zext <2 x i32> %a to <2 x i64>
  ret <2 x i64> %b
}
=>
define <2 x i64> @bar(<2 x i65> %t) {
%0:
  %1 = trunc <2 x i65> %t to <2 x i64>
  %b = and <2 x i64> %1, { 4294967295, 4294967295 }
  ret <2 x i64> %b
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @bars(<2 x i65> %t) {
%0:
  %a = trunc <2 x i65> %t to <2 x i32>
  %b = sext <2 x i32> %a to <2 x i64>
  ret <2 x i64> %b
}
=>
define <2 x i64> @bars(<2 x i65> %t) {
%0:
  %a = trunc <2 x i65> %t to <2 x i32>
  %b = sext <2 x i32> %a to <2 x i64>
  ret <2 x i64> %b
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i64> @quxs(<2 x i64> %t) {
%0:
  %a = trunc <2 x i64> %t to <2 x i32>
  %b = sext <2 x i32> %a to <2 x i64>
  ret <2 x i64> %b
}
=>
define <2 x i64> @quxs(<2 x i64> %t) {
%0:
  %1 = shl <2 x i64> %t, { 32, 32 }
  %b = ashr exact <2 x i64> %1, { 32, 32 }
  ret <2 x i64> %b
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @quxt(<2 x i64> %t) {
%0:
  %a = shl <2 x i64> %t, { 32, 32 }
  %b = ashr <2 x i64> %a, { 32, 32 }
  ret <2 x i64> %b
}
=>
define <2 x i64> @quxt(<2 x i64> %t) {
%0:
  %a = shl <2 x i64> %t, { 32, 32 }
  %b = ashr exact <2 x i64> %a, { 32, 32 }
  ret <2 x i64> %b
}
Transformation seems to be correct!


----------------------------------------
define <2 x double> @fa(<2 x double> %t) {
%0:
  %a = fptrunc <2 x double> %t to <2 x float>
  %b = fpext <2 x float> %a to <2 x double>
  ret <2 x double> %b
}
=>
define <2 x double> @fa(<2 x double> %t) {
%0:
  %a = fptrunc <2 x double> %t to <2 x float>
  %b = fpext <2 x float> %a to <2 x double>
  ret <2 x double> %b
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x double> @fb(<2 x double> %t) {
%0:
  %a = fptoui <2 x double> %t to <2 x i64>
  %b = uitofp <2 x i64> %a to <2 x double>
  ret <2 x double> %b
}
=>
define <2 x double> @fb(<2 x double> %t) {
%0:
  %a = fptoui <2 x double> %t to <2 x i64>
  %b = uitofp <2 x i64> %a to <2 x double>
  ret <2 x double> %b
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x double> @fc(<2 x double> %t) {
%0:
  %a = fptosi <2 x double> %t to <2 x i64>
  %b = sitofp <2 x i64> %a to <2 x double>
  ret <2 x double> %b
}
=>
define <2 x double> @fc(<2 x double> %t) {
%0:
  %a = fptosi <2 x double> %t to <2 x i64>
  %b = sitofp <2 x i64> %a to <2 x double>
  ret <2 x double> %b
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @f(i32 %a) {
%0:
  %dim = insertelement <4 x i32> undef, i32 %a, i32 0
  %dim30 = insertelement <4 x i32> %dim, i32 %a, i32 1
  %dim31 = insertelement <4 x i32> %dim30, i32 %a, i32 2
  %dim32 = insertelement <4 x i32> %dim31, i32 %a, i32 3
  %offset_ptr = gep * null, 16 x i32 1
  %offset_int = ptrtoint * %offset_ptr to i64
  %sizeof32 = trunc i64 %offset_int to i32
  %smearinsert33 = insertelement <4 x i32> undef, i32 %sizeof32, i32 0
  %smearinsert34 = insertelement <4 x i32> %smearinsert33, i32 %sizeof32, i32 1
  %smearinsert35 = insertelement <4 x i32> %smearinsert34, i32 %sizeof32, i32 2
  %smearinsert36 = insertelement <4 x i32> %smearinsert35, i32 %sizeof32, i32 3
  %delta_scale = mul <4 x i32> %dim32, %smearinsert36
  %offset_delta = add <4 x i32> { 0, 0, 0, 0 }, %delta_scale
  %offset_varying_delta = add <4 x i32> %offset_delta, undef
  ret <4 x float> undef
}
=>
define <4 x float> @f(i32 %a) {
%0:
  ret <4 x float> undef
}
Transformation seems to be correct!


----------------------------------------
define <8 x i32> @pr24458(<8 x float> %n) {
%0:
  %notequal_b_load_.i = fcmp une <8 x float> %n, { 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000 }
  %equal_a_load72_.i = fcmp ueq <8 x float> %n, { 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000 }
  %notequal_b_load__to_boolvec.i = sext <8 x i1> %notequal_b_load_.i to <8 x i32>
  %equal_a_load72__to_boolvec.i = sext <8 x i1> %equal_a_load72_.i to <8 x i32>
  %wrong = or <8 x i32> %notequal_b_load__to_boolvec.i, %equal_a_load72__to_boolvec.i
  ret <8 x i32> %wrong
}
=>
define <8 x i32> @pr24458(<8 x float> %n) {
%0:
  ret <8 x i32> { 4294967295, 4294967295, 4294967295, 4294967295, 4294967295, 4294967295, 4294967295, 4294967295 }
}
Transformation seems to be correct!


----------------------------------------
define <3 x i16> @trunc_inselt_undef(i32 %x) {
%0:
  %vec = insertelement <3 x i32> undef, i32 %x, i32 1
  %trunc = trunc <3 x i32> %vec to <3 x i16>
  ret <3 x i16> %trunc
}
=>
define <3 x i16> @trunc_inselt_undef(i32 %x) {
%0:
  %1 = trunc i32 %x to i16
  %trunc = insertelement <3 x i16> undef, i16 %1, i32 1
  ret <3 x i16> %trunc
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fptrunc_inselt_undef(double %x, i32 %index) {
%0:
  %vec = insertelement <2 x double> undef, double %x, i32 %index
  %trunc = fptrunc <2 x double> %vec to <2 x float>
  ret <2 x float> %trunc
}
=>
define <2 x float> @fptrunc_inselt_undef(double %x, i32 %index) {
%0:
  %1 = fptrunc double %x to float
  %trunc = insertelement <2 x float> undef, float %1, i32 %index
  ret <2 x float> %trunc
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <3 x i16> @trunc_inselt1(i32 %x) {
%0:
  %vec = insertelement <3 x i32> { 3, 4294967294, 65536 }, i32 %x, i32 1
  %trunc = trunc <3 x i32> %vec to <3 x i16>
  ret <3 x i16> %trunc
}
=>
define <3 x i16> @trunc_inselt1(i32 %x) {
%0:
  %vec = insertelement <3 x i32> { 3, poison, 65536 }, i32 %x, i32 1
  %trunc = trunc <3 x i32> %vec to <3 x i16>
  ret <3 x i16> %trunc
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fptrunc_inselt1(double %x, i32 %index) {
%0:
  %vec = insertelement <2 x double> { undef, 3.000000 }, double %x, i32 %index
  %trunc = fptrunc <2 x double> %vec to <2 x float>
  ret <2 x float> %trunc
}
=>
define <2 x float> @fptrunc_inselt1(double %x, i32 %index) {
%0:
  %vec = insertelement <2 x double> { undef, 3.000000 }, double %x, i32 %index
  %trunc = fptrunc <2 x double> %vec to <2 x float>
  ret <2 x float> %trunc
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <8 x i16> @trunc_inselt2(<8 x i32> %x, i32 %index) {
%0:
  %vec = insertelement <8 x i32> %x, i32 1048576, i32 %index
  %trunc = trunc <8 x i32> %vec to <8 x i16>
  ret <8 x i16> %trunc
}
=>
define <8 x i16> @trunc_inselt2(<8 x i32> %x, i32 %index) {
%0:
  %vec = insertelement <8 x i32> %x, i32 1048576, i32 %index
  %trunc = trunc <8 x i32> %vec to <8 x i16>
  ret <8 x i16> %trunc
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <3 x float> @fptrunc_inselt2(<3 x double> %x) {
%0:
  %vec = insertelement <3 x double> %x, double 4.000000, i32 2
  %trunc = fptrunc <3 x double> %vec to <3 x float>
  ret <3 x float> %trunc
}
=>
define <3 x float> @fptrunc_inselt2(<3 x double> %x) {
%0:
  %vec = insertelement <3 x double> %x, double 4.000000, i32 2
  %trunc = fptrunc <3 x double> %vec to <3 x float>
  ret <3 x float> %trunc
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i64> @sext_less_casting_with_wideop(<2 x i64> %x, <2 x i64> %y) {
%0:
  %xnarrow = trunc <2 x i64> %x to <2 x i32>
  %ynarrow = trunc <2 x i64> %y to <2 x i32>
  %mul = mul <2 x i32> %xnarrow, %ynarrow
  %r = sext <2 x i32> %mul to <2 x i64>
  ret <2 x i64> %r
}
=>
define <2 x i64> @sext_less_casting_with_wideop(<2 x i64> %x, <2 x i64> %y) {
%0:
  %xnarrow = trunc <2 x i64> %x to <2 x i32>
  %ynarrow = trunc <2 x i64> %y to <2 x i32>
  %mul = mul <2 x i32> %xnarrow, %ynarrow
  %r = sext <2 x i32> %mul to <2 x i64>
  ret <2 x i64> %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i64> @zext_less_casting_with_wideop(<2 x i64> %x, <2 x i64> %y) {
%0:
  %xnarrow = trunc <2 x i64> %x to <2 x i32>
  %ynarrow = trunc <2 x i64> %y to <2 x i32>
  %mul = mul <2 x i32> %xnarrow, %ynarrow
  %r = zext <2 x i32> %mul to <2 x i64>
  ret <2 x i64> %r
}
=>
define <2 x i64> @zext_less_casting_with_wideop(<2 x i64> %x, <2 x i64> %y) {
%0:
  %xnarrow = trunc <2 x i64> %x to <2 x i32>
  %ynarrow = trunc <2 x i64> %y to <2 x i32>
  %mul = mul <2 x i32> %xnarrow, %ynarrow
  %r = zext <2 x i32> %mul to <2 x i64>
  ret <2 x i64> %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @sitofp_shuf(<4 x i32> %x) {
%0:
  %s = shufflevector <4 x i32> %x, <4 x i32> poison, 1, 2, 3, 4294967295
  %r = sitofp <4 x i32> %s to <4 x float>
  ret <4 x float> %r
}
=>
define <4 x float> @sitofp_shuf(<4 x i32> %x) {
%0:
  %1 = sitofp <4 x i32> %x to <4 x float>
  %r = shufflevector <4 x float> %1, <4 x float> undef, 1, 2, 3, 4294967295
  ret <4 x float> %r
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
<4 x i32> %x = < poison, poison, poison, poison >

Source:
<4 x i32> %s = < poison, poison, poison, any >
<4 x float> %r = < poison, poison, poison, #x00000000 (+0.0)	[based on undef value] >

Target:
<4 x float> %1 = < poison, poison, poison, poison >
<4 x float> %r = < poison, poison, poison, #x02000010 (0.000000000000?) >
Source value: < poison, poison, poison, #x00000000 (+0.0) >
Target value: < poison, poison, poison, #x02000010 (0.000000000000?) >


------------------- SMT STATS -------------------
Num queries: 61
Num invalid: 0
Num skips:   0
Num trivial: 63 (50.8%)
Num timeout: 10 (16.4%)
Num errors:  0 (0.0%)
Num SAT:     22 (36.1%)
Num UNSAT:   29 (47.5%)
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/vector-casts.ll

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

<-- Back