Test Failure: Transforms/InstCombine/vec_shuffle-inseltpoison.ll

Test source: git

Log:

Source: <stdin>
ERROR: Unsupported type: <vscale x 4 x float>
ERROR: Unsupported instruction:   %__constexpr_1 = ptrtoint <4 x i32> (<4 x i32>)* @pr20114 to i64
ERROR: Unsupported instruction:   %__constexpr_0 = bitcast <2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @pr20114 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @pr20114 to i64)> to <4 x i32>
ERROR: Unsupported instruction:   %masked_new.i.i.i = and <4 x i32> bitcast (<2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @pr20114 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @pr20114 to i64)> to <4 x i32>), %mask01.i
ERROR: Unsupported type: <vscale x 4 x i32>
ERROR: Unsupported instruction:   %__constexpr_1 = ptrtoint <4 x i32> (<4 x i32>)* @PR46872 to i64
ERROR: Unsupported instruction:   %__constexpr_0 = bitcast <2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64)> to <4 x i32>
ERROR: Unsupported instruction:   %a = and <4 x i32> %s, bitcast (<2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64)> to <4 x i32>)

----------------------------------------
define <4 x float> @test1(<4 x float> %v1) {
%0:
  %v2 = shufflevector <4 x float> %v1, <4 x float> poison, 0, 1, 2, 3
  ret <4 x float> %v2
}
=>
define <4 x float> @test1(<4 x float> %v1) {
%0:
  ret <4 x float> %v1
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @test2(<4 x float> %v1) {
%0:
  %v2 = shufflevector <4 x float> %v1, <4 x float> %v1, 0, 5, 2, 7
  ret <4 x float> %v2
}
=>
define <4 x float> @test2(<4 x float> %v1) {
%0:
  ret <4 x float> %v1
}
Transformation seems to be correct!


----------------------------------------
define float @test3(<4 x float> %A, <4 x float> %B, float %f) {
%0:
  %C = insertelement <4 x float> %A, float %f, i32 0
  %D = shufflevector <4 x float> %C, <4 x float> %B, 5, 0, 2, 7
  %E = extractelement <4 x float> %D, i32 1
  ret float %E
}
=>
define float @test3(<4 x float> %A, <4 x float> %B, float %f) {
%0:
  ret float %f
}
Transformation seems to be correct!


----------------------------------------
define i32 @test4(<4 x i32> %X) {
%0:
  %t = shufflevector <4 x i32> %X, <4 x i32> poison, 0, 0, 0, 0
  %r = extractelement <4 x i32> %t, i32 0
  ret i32 %r
}
=>
define i32 @test4(<4 x i32> %X) {
%0:
  %r = extractelement <4 x i32> %X, i32 0
  ret i32 %r
}
Transformation seems to be correct!


----------------------------------------
define i32 @test5(<4 x i32> %X) {
%0:
  %t = shufflevector <4 x i32> %X, <4 x i32> poison, 3, 2, 4294967295, 4294967295
  %r = extractelement <4 x i32> %t, i32 0
  ret i32 %r
}
=>
define i32 @test5(<4 x i32> %X) {
%0:
  %r = extractelement <4 x i32> %X, i32 3
  ret i32 %r
}
Transformation seems to be correct!


----------------------------------------
define float @test6(<4 x float> %X) {
%0:
  %X1 = bitcast <4 x float> %X to <4 x i32>
  %t = shufflevector <4 x i32> %X1, <4 x i32> poison, 0, 0, 0, 0
  %t2 = bitcast <4 x i32> %t to <4 x float>
  %r = extractelement <4 x float> %t2, i32 0
  ret float %r
}
=>
define float @test6(<4 x float> %X) {
%0:
  %r = extractelement <4 x float> %X, i32 0
  ret float %r
}
Transformation seems to be correct!

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

----------------------------------------
define <4 x float> @test7(<4 x float> %x) {
%0:
  %r = shufflevector <4 x float> %x, <4 x float> poison, 0, 1, 6, 7
  ret <4 x float> %r
}
=>
define <4 x float> @test7(<4 x float> %x) {
%0:
  %r = shufflevector <4 x float> %x, <4 x float> poison, 0, 1, 4294967295, 4294967295
  ret <4 x float> %r
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @test8(<4 x float> %x, <4 x float> %y) {
%0:
  %t4 = extractelement <4 x float> %x, i32 1
  %t2 = extractelement <4 x float> %x, i32 3
  %t1 = extractelement <4 x float> %y, i32 0
  %t128 = insertelement <4 x float> poison, float %t4, i32 0
  %t130 = insertelement <4 x float> %t128, float undef, i32 1
  %t132 = insertelement <4 x float> %t130, float %t2, i32 2
  %t134 = insertelement <4 x float> %t132, float %t1, i32 3
  ret <4 x float> %t134
}
=>
define <4 x float> @test8(<4 x float> %x, <4 x float> %y) {
%0:
  %t134 = shufflevector <4 x float> %x, <4 x float> %y, 1, 4294967295, 3, 4
  ret <4 x float> %t134
}
Transformation seems to be correct!


----------------------------------------
define <4 x i8> @test9(<16 x i8> %t6) {
%0:
  %t7 = shufflevector <16 x i8> %t6, <16 x i8> poison, 13, 9, 4, 13
  %t9 = shufflevector <4 x i8> %t7, <4 x i8> poison, 3, 1, 2, 0
  ret <4 x i8> %t9
}
=>
define <4 x i8> @test9(<16 x i8> %t6) {
%0:
  %t9 = shufflevector <16 x i8> %t6, <16 x i8> poison, 13, 9, 4, 13
  ret <4 x i8> %t9
}
Transformation seems to be correct!


----------------------------------------
define <4 x i8> @test9a(<16 x i8> %t6) {
%0:
  %t7 = shufflevector <16 x i8> %t6, <16 x i8> poison, 4294967295, 9, 4, 8
  %t9 = shufflevector <4 x i8> %t7, <4 x i8> poison, 3, 1, 2, 0
  ret <4 x i8> %t9
}
=>
define <4 x i8> @test9a(<16 x i8> %t6) {
%0:
  %t7 = shufflevector <16 x i8> %t6, <16 x i8> poison, 4294967295, 9, 4, 8
  %t9 = shufflevector <4 x i8> %t7, <4 x i8> poison, 3, 1, 2, 4294967295
  ret <4 x i8> %t9
}
Transformation seems to be correct!


----------------------------------------
define <4 x i8> @test9b(<4 x i8> %t6, <4 x i8> %t7) {
%0:
  %t1 = shufflevector <4 x i8> %t6, <4 x i8> %t7, 0, 1, 4, 5, 4, 5, 2, 3
  %t9 = shufflevector <8 x i8> %t1, <8 x i8> poison, 0, 1, 4, 5
  ret <4 x i8> %t9
}
=>
define <4 x i8> @test9b(<4 x i8> %t6, <4 x i8> %t7) {
%0:
  %t9 = shufflevector <4 x i8> %t6, <4 x i8> %t7, 0, 1, 4, 5
  ret <4 x i8> %t9
}
Transformation seems to be correct!


----------------------------------------
define <4 x i32> @test10(<4 x i32> %t5) {
%0:
  %t6 = shufflevector <4 x i32> %t5, <4 x i32> poison, 1, 4294967295, 4294967295, 4294967295
  %t7 = shufflevector <4 x i32> %t6, <4 x i32> poison, 0, 0, 0, 0
  ret <4 x i32> %t7
}
=>
define <4 x i32> @test10(<4 x i32> %t5) {
%0:
  %t7 = shufflevector <4 x i32> %t5, <4 x i32> poison, 1, 1, 1, 1
  ret <4 x i32> %t7
}
Transformation seems to be correct!


----------------------------------------
define <8 x i8> @test11(<16 x i8> %t6) {
%0:
  %t1 = shufflevector <16 x i8> %t6, <16 x i8> poison, 0, 1, 2, 3
  %t2 = shufflevector <16 x i8> %t6, <16 x i8> poison, 4, 5, 6, 7
  %t3 = shufflevector <4 x i8> %t1, <4 x i8> %t2, 0, 1, 2, 3, 4, 5, 6, 7
  ret <8 x i8> %t3
}
=>
define <8 x i8> @test11(<16 x i8> %t6) {
%0:
  %t3 = shufflevector <16 x i8> %t6, <16 x i8> undef, 0, 1, 2, 3, 4, 5, 6, 7
  ret <8 x i8> %t3
}
Transformation seems to be correct!


----------------------------------------
define <8 x i8> @test12(<8 x i8> %t6, <8 x i8> %t2) {
%0:
  %t1 = shufflevector <8 x i8> %t6, <8 x i8> poison, 0, 1, 2, 3, 5, 4, 4294967295, 7
  %t3 = shufflevector <8 x i8> %t1, <8 x i8> %t2, 0, 1, 2, 3, 9, 8, 11, 12
  ret <8 x i8> %t3
}
=>
define <8 x i8> @test12(<8 x i8> %t6, <8 x i8> %t2) {
%0:
  %t3 = shufflevector <8 x i8> %t6, <8 x i8> %t2, 0, 1, 2, 3, 9, 8, 11, 12
  ret <8 x i8> %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <8 x i8> @test12a(<8 x i8> %t6, <8 x i8> %t2) {
%0:
  %t1 = shufflevector <8 x i8> %t6, <8 x i8> poison, 0, 1, 2, 3, 5, 4, 4294967295, 7
  %t3 = shufflevector <8 x i8> %t2, <8 x i8> %t1, 0, 3, 1, 4, 8, 9, 10, 11
  ret <8 x i8> %t3
}
=>
define <8 x i8> @test12a(<8 x i8> %t6, <8 x i8> %t2) {
%0:
  %t3 = shufflevector <8 x i8> %t2, <8 x i8> %t6, 0, 3, 1, 4, 8, 9, 10, 11
  ret <8 x i8> %t3
}
Transformation seems to be correct!


----------------------------------------
define <2 x i8> @extract_subvector_of_shuffle(<2 x i8> %x, <2 x i8> %y) {
%0:
  %shuf = shufflevector <2 x i8> %x, <2 x i8> %y, 0, 2, 0
  %extract_subv = shufflevector <3 x i8> %shuf, <3 x i8> poison, 0, 1
  ret <2 x i8> %extract_subv
}
=>
define <2 x i8> @extract_subvector_of_shuffle(<2 x i8> %x, <2 x i8> %y) {
%0:
  %extract_subv = shufflevector <2 x i8> %x, <2 x i8> %y, 0, 2
  ret <2 x i8> %extract_subv
}
Transformation seems to be correct!


----------------------------------------
define <4 x i8> @extract_subvector_of_shuffle_undefs_types(<2 x i8> %x, <2 x i8> %y) {
%0:
  %shuf = shufflevector <2 x i8> %x, <2 x i8> %y, 4294967295, 2, 0, 1, 0
  %extract_subv = shufflevector <5 x i8> %shuf, <5 x i8> poison, 0, 1, 2, 4294967295
  ret <4 x i8> %extract_subv
}
=>
define <4 x i8> @extract_subvector_of_shuffle_undefs_types(<2 x i8> %x, <2 x i8> %y) {
%0:
  %extract_subv = shufflevector <2 x i8> %x, <2 x i8> %y, 4294967295, 2, 0, 4294967295
  ret <4 x i8> %extract_subv
}
Transformation seems to be correct!


----------------------------------------
define <4 x i8> @extract_subvector_of_shuffle_extra_use(<2 x i8> %x, <2 x i8> %y) {
%0:
  %shuf = shufflevector <2 x i8> %x, <2 x i8> %y, 4294967295, 2, 0, 1, 0
  call void @use_v5i8(<5 x i8> %shuf)
  %extract_subv = shufflevector <5 x i8> %shuf, <5 x i8> poison, 0, 1, 2, 4294967295
  ret <4 x i8> %extract_subv
}
=>
define <4 x i8> @extract_subvector_of_shuffle_extra_use(<2 x i8> %x, <2 x i8> %y) {
%0:
  %shuf = shufflevector <2 x i8> %x, <2 x i8> %y, 4294967295, 2, 0, 1, 0
  call void @use_v5i8(<5 x i8> %shuf)
  %extract_subv = shufflevector <5 x i8> %shuf, <5 x i8> poison, 0, 1, 2, 4294967295
  ret <4 x i8> %extract_subv
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i8> @test13a(i8 %x1, i8 %x2) {
%0:
  %A = insertelement <2 x i8> poison, i8 %x1, i32 0
  %B = insertelement <2 x i8> %A, i8 %x2, i32 1
  %C = add <2 x i8> %B, { 5, 7 }
  %D = shufflevector <2 x i8> %C, <2 x i8> poison, 1, 0
  ret <2 x i8> %D
}
=>
define <2 x i8> @test13a(i8 %x1, i8 %x2) {
%0:
  %1 = insertelement <2 x i8> undef, i8 %x1, i32 1
  %2 = insertelement <2 x i8> %1, i8 %x2, i32 0
  %3 = add <2 x i8> %2, { 7, 5 }
  ret <2 x i8> %3
}
Transformation seems to be correct!


----------------------------------------
define <3 x i32> @add_wider(i32 %y, i32 %z) {
%0:
  %i0 = insertelement <2 x i32> poison, i32 %y, i32 0
  %i1 = insertelement <2 x i32> %i0, i32 %z, i32 1
  %a = add <2 x i32> %i1, { 255, 255 }
  %ext = shufflevector <2 x i32> %a, <2 x i32> poison, 0, 1, 4294967295
  ret <3 x i32> %ext
}
=>
define <3 x i32> @add_wider(i32 %y, i32 %z) {
%0:
  %i0 = insertelement <2 x i32> poison, i32 %y, i32 0
  %i1 = insertelement <2 x i32> %i0, i32 %z, i32 1
  %a = add <2 x i32> %i1, { 255, 255 }
  %ext = shufflevector <2 x i32> %a, <2 x i32> poison, 0, 1, 4294967295
  ret <3 x i32> %ext
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <3 x i32> @div_wider(i32 %y, i32 %z) {
%0:
  %i0 = insertelement <2 x i32> poison, i32 %y, i32 0
  %i1 = insertelement <2 x i32> %i0, i32 %z, i32 1
  %a = sdiv <2 x i32> %i1, { 255, 255 }
  %ext = shufflevector <2 x i32> %a, <2 x i32> poison, 0, 1, 4294967295
  ret <3 x i32> %ext
}
=>
define <3 x i32> @div_wider(i32 %y, i32 %z) {
%0:
  %i0 = insertelement <2 x i32> poison, i32 %y, i32 0
  %i1 = insertelement <2 x i32> %i0, i32 %z, i32 1
  %a = sdiv <2 x i32> %i1, { 255, 255 }
  %ext = shufflevector <2 x i32> %a, <2 x i32> poison, 0, 1, 4294967295
  ret <3 x i32> %ext
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <3 x i8> @fold_inselts_with_widening_shuffle(i8 %x, i8 %y) {
%0:
  %ins0 = insertelement <2 x i8> poison, i8 %x, i32 0
  %ins1 = insertelement <2 x i8> %ins0, i8 %y, i32 1
  %widen = shufflevector <2 x i8> %ins1, <2 x i8> poison, 0, 1, 4294967295
  ret <3 x i8> %widen
}
=>
define <3 x i8> @fold_inselts_with_widening_shuffle(i8 %x, i8 %y) {
%0:
  %1 = insertelement <3 x i8> undef, i8 %x, i32 0
  %2 = insertelement <3 x i8> %1, i8 %y, i32 1
  ret <3 x i8> %2
}
Transformation seems to be correct!


----------------------------------------
define <2 x i8> @test13b(i8 %x) {
%0:
  %A = insertelement <2 x i8> poison, i8 %x, i32 0
  %B = shufflevector <2 x i8> %A, <2 x i8> poison, 4294967295, 0
  ret <2 x i8> %B
}
=>
define <2 x i8> @test13b(i8 %x) {
%0:
  %B = insertelement <2 x i8> poison, i8 %x, i32 1
  ret <2 x i8> %B
}
Transformation doesn't verify!
ERROR: Target is more poisonous than source

Example:
i8 %x = poison

Source:
<2 x i8> %A = < poison, poison >
<2 x i8> %B = < any, poison >

Target:
<2 x i8> %B = < poison, poison >
Source value: < any, poison >
Target value: < poison, poison >


------------------- SMT STATS -------------------
Num queries: 71
Num invalid: 0
Num skips:   0
Num trivial: 75 (51.4%)
Num timeout: 1 (1.4%)
Num errors:  0 (0.0%)
Num SAT:     27 (38.0%)
Num UNSAT:   43 (60.6%)
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_shuffle-inseltpoison.ll

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

<-- Back