Test Failure: Transforms/SLPVectorizer/X86/hadd.ll

Test source: git

Comments: LLVM PR44185

Log:

Source: <stdin>

----------------------------------------
define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) {
%0:
  %a0 = extractelement <2 x double> %a, i32 0
  %a1 = extractelement <2 x double> %a, i32 1
  %b0 = extractelement <2 x double> %b, i32 0
  %b1 = extractelement <2 x double> %b, i32 1
  %r0 = fadd double %a0, %a1, exceptions=ignore
  %r1 = fadd double %b0, %b1, exceptions=ignore
  %r00 = insertelement <2 x double> undef, double %r0, i32 0
  %r01 = insertelement <2 x double> %r00, double %r1, i32 1
  ret <2 x double> %r01
}
=>
define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) {
%0:
  %1 = shufflevector <2 x double> %a, <2 x double> %b, 0, 2
  %2 = shufflevector <2 x double> %a, <2 x double> %b, 1, 3
  %3 = fadd <2 x double> %1, %2, exceptions=ignore
  ret <2 x double> %3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x float> @test_v4f32(<4 x float> %a, <4 x float> %b) {
%0:
  %a0 = extractelement <4 x float> %a, i32 0
  %a1 = extractelement <4 x float> %a, i32 1
  %a2 = extractelement <4 x float> %a, i32 2
  %a3 = extractelement <4 x float> %a, i32 3
  %b0 = extractelement <4 x float> %b, i32 0
  %b1 = extractelement <4 x float> %b, i32 1
  %b2 = extractelement <4 x float> %b, i32 2
  %b3 = extractelement <4 x float> %b, i32 3
  %r0 = fadd float %a0, %a1, exceptions=ignore
  %r1 = fadd float %a2, %a3, exceptions=ignore
  %r2 = fadd float %b0, %b1, exceptions=ignore
  %r3 = fadd float %b2, %b3, exceptions=ignore
  %r00 = insertelement <4 x float> undef, float %r0, i32 0
  %r01 = insertelement <4 x float> %r00, float %r1, i32 1
  %r02 = insertelement <4 x float> %r01, float %r2, i32 2
  %r03 = insertelement <4 x float> %r02, float %r3, i32 3
  ret <4 x float> %r03
}
=>
define <4 x float> @test_v4f32(<4 x float> %a, <4 x float> %b) {
%0:
  %1 = shufflevector <4 x float> %a, <4 x float> %b, 0, 2, 4, 6
  %2 = shufflevector <4 x float> %a, <4 x float> %b, 1, 3, 5, 7
  %3 = fadd <4 x float> %1, %2, exceptions=ignore
  ret <4 x float> %3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i64> @test_v2i64(<2 x i64> %a, <2 x i64> %b) {
%0:
  %a0 = extractelement <2 x i64> %a, i32 0
  %a1 = extractelement <2 x i64> %a, i32 1
  %b0 = extractelement <2 x i64> %b, i32 0
  %b1 = extractelement <2 x i64> %b, i32 1
  %r0 = add i64 %a0, %a1
  %r1 = add i64 %b0, %b1
  %r00 = insertelement <2 x i64> undef, i64 %r0, i32 0
  %r01 = insertelement <2 x i64> %r00, i64 %r1, i32 1
  ret <2 x i64> %r01
}
=>
define <2 x i64> @test_v2i64(<2 x i64> %a, <2 x i64> %b) {
%0:
  %1 = shufflevector <2 x i64> %a, <2 x i64> %b, 0, 2
  %2 = shufflevector <2 x i64> %a, <2 x i64> %b, 1, 3
  %3 = add <2 x i64> %1, %2
  ret <2 x i64> %3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x i32> @test_v4i32(<4 x i32> %a, <4 x i32> %b) {
%0:
  %a0 = extractelement <4 x i32> %a, i32 0
  %a1 = extractelement <4 x i32> %a, i32 1
  %a2 = extractelement <4 x i32> %a, i32 2
  %a3 = extractelement <4 x i32> %a, i32 3
  %b0 = extractelement <4 x i32> %b, i32 0
  %b1 = extractelement <4 x i32> %b, i32 1
  %b2 = extractelement <4 x i32> %b, i32 2
  %b3 = extractelement <4 x i32> %b, i32 3
  %r0 = add i32 %a0, %a1
  %r1 = add i32 %a2, %a3
  %r2 = add i32 %b0, %b1
  %r3 = add i32 %b2, %b3
  %r00 = insertelement <4 x i32> undef, i32 %r0, i32 0
  %r01 = insertelement <4 x i32> %r00, i32 %r1, i32 1
  %r02 = insertelement <4 x i32> %r01, i32 %r2, i32 2
  %r03 = insertelement <4 x i32> %r02, i32 %r3, i32 3
  ret <4 x i32> %r03
}
=>
define <4 x i32> @test_v4i32(<4 x i32> %a, <4 x i32> %b) {
%0:
  %1 = shufflevector <4 x i32> %a, <4 x i32> %b, 0, 2, 4, 6
  %2 = shufflevector <4 x i32> %a, <4 x i32> %b, 1, 3, 5, 7
  %3 = add <4 x i32> %1, %2
  ret <4 x i32> %3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <8 x i16> @test_v8i16(<8 x i16> %a, <8 x i16> %b) {
%0:
  %a0 = extractelement <8 x i16> %a, i32 0
  %a1 = extractelement <8 x i16> %a, i32 1
  %a2 = extractelement <8 x i16> %a, i32 2
  %a3 = extractelement <8 x i16> %a, i32 3
  %a4 = extractelement <8 x i16> %a, i32 4
  %a5 = extractelement <8 x i16> %a, i32 5
  %a6 = extractelement <8 x i16> %a, i32 6
  %a7 = extractelement <8 x i16> %a, i32 7
  %b0 = extractelement <8 x i16> %b, i32 0
  %b1 = extractelement <8 x i16> %b, i32 1
  %b2 = extractelement <8 x i16> %b, i32 2
  %b3 = extractelement <8 x i16> %b, i32 3
  %b4 = extractelement <8 x i16> %b, i32 4
  %b5 = extractelement <8 x i16> %b, i32 5
  %b6 = extractelement <8 x i16> %b, i32 6
  %b7 = extractelement <8 x i16> %b, i32 7
  %r0 = add i16 %a0, %a1
  %r1 = add i16 %a2, %a3
  %r2 = add i16 %a4, %a5
  %r3 = add i16 %a6, %a7
  %r4 = add i16 %b0, %b1
  %r5 = add i16 %b2, %b3
  %r6 = add i16 %b4, %b5
  %r7 = add i16 %b6, %b7
  %r00 = insertelement <8 x i16> undef, i16 %r0, i32 0
  %r01 = insertelement <8 x i16> %r00, i16 %r1, i32 1
  %r02 = insertelement <8 x i16> %r01, i16 %r2, i32 2
  %r03 = insertelement <8 x i16> %r02, i16 %r3, i32 3
  %r04 = insertelement <8 x i16> %r03, i16 %r4, i32 4
  %r05 = insertelement <8 x i16> %r04, i16 %r5, i32 5
  %r06 = insertelement <8 x i16> %r05, i16 %r6, i32 6
  %r07 = insertelement <8 x i16> %r06, i16 %r7, i32 7
  ret <8 x i16> %r07
}
=>
define <8 x i16> @test_v8i16(<8 x i16> %a, <8 x i16> %b) {
%0:
  %1 = shufflevector <8 x i16> %a, <8 x i16> %b, 0, 2, 4, 6, 8, 10, 12, 14
  %2 = shufflevector <8 x i16> %a, <8 x i16> %b, 1, 3, 5, 7, 9, 11, 13, 15
  %3 = add <8 x i16> %1, %2
  ret <8 x i16> %3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @test_v4f32_v2f32_store(<4 x float> %f, ptr %p) {
%0:
  %x0 = extractelement <4 x float> %f, i64 0
  %x1 = extractelement <4 x float> %f, i64 1
  %add01 = fadd float %x0, %x1, exceptions=ignore
  store float %add01, ptr %p, align 4
  %x2 = extractelement <4 x float> %f, i64 2
  %x3 = extractelement <4 x float> %f, i64 3
  %add23 = fadd float %x2, %x3, exceptions=ignore
  %p23 = gep inbounds ptr %p, 4 x i64 1
  store float %add23, ptr %p23, align 4
  ret void
}
=>
define void @test_v4f32_v2f32_store(<4 x float> %f, ptr %p) {
%0:
  %1 = shufflevector <4 x float> %f, <4 x float> undef, 1, 2
  %2 = shufflevector <4 x float> %f, <4 x float> undef, 0, 3
  %3 = fadd <2 x float> %1, %2, exceptions=ignore
  %4 = bitcast ptr %p to ptr
  store <2 x float> %3, ptr %4, align 4
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x double> @test_v4f64(<4 x double> %a, <4 x double> %b) {
%0:
  %a0 = extractelement <4 x double> %a, i32 0
  %a1 = extractelement <4 x double> %a, i32 1
  %a2 = extractelement <4 x double> %a, i32 2
  %a3 = extractelement <4 x double> %a, i32 3
  %b0 = extractelement <4 x double> %b, i32 0
  %b1 = extractelement <4 x double> %b, i32 1
  %b2 = extractelement <4 x double> %b, i32 2
  %b3 = extractelement <4 x double> %b, i32 3
  %r0 = fadd double %a0, %a1, exceptions=ignore
  %r1 = fadd double %b0, %b1, exceptions=ignore
  %r2 = fadd double %a2, %a3, exceptions=ignore
  %r3 = fadd double %b2, %b3, exceptions=ignore
  %r00 = insertelement <4 x double> undef, double %r0, i32 0
  %r01 = insertelement <4 x double> %r00, double %r1, i32 1
  %r02 = insertelement <4 x double> %r01, double %r2, i32 2
  %r03 = insertelement <4 x double> %r02, double %r3, i32 3
  ret <4 x double> %r03
}
=>
define <4 x double> @test_v4f64(<4 x double> %a, <4 x double> %b) {
%0:
  %1 = shufflevector <4 x double> %a, <4 x double> %b, 0, 4
  %2 = shufflevector <4 x double> %a, <4 x double> %b, 1, 5
  %3 = fadd <2 x double> %1, %2, exceptions=ignore
  %4 = shufflevector <4 x double> %a, <4 x double> %b, 2, 6
  %5 = shufflevector <4 x double> %a, <4 x double> %b, 3, 7
  %6 = fadd <2 x double> %4, %5, exceptions=ignore
  %r031 = shufflevector <2 x double> %3, <2 x double> %6, 0, 1, 2, 3
  ret <4 x double> %r031
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x double> @test_v4f64_partial_swizzle(<4 x double> %a, <4 x double> %b) {
%0:
  %a0 = extractelement <4 x double> %a, i64 0
  %a1 = extractelement <4 x double> %a, i64 1
  %b0 = extractelement <4 x double> %b, i64 0
  %b1 = extractelement <4 x double> %b, i64 1
  %b2 = extractelement <4 x double> %b, i32 2
  %b3 = extractelement <4 x double> %b, i32 3
  %r0 = fadd double %a0, %a1, exceptions=ignore
  %r2 = fadd double %b0, %b1, exceptions=ignore
  %r3 = fadd double %b2, %b3, exceptions=ignore
  %r00 = insertelement <4 x double> undef, double %r0, i32 0
  %r02 = insertelement <4 x double> %r00, double %r2, i32 2
  %r03 = insertelement <4 x double> %r02, double %r3, i32 3
  ret <4 x double> %r03
}
=>
define <4 x double> @test_v4f64_partial_swizzle(<4 x double> %a, <4 x double> %b) {
%0:
  %b2 = extractelement <4 x double> %b, i64 2
  %b3 = extractelement <4 x double> %b, i64 3
  %1 = shufflevector <4 x double> %a, <4 x double> %b, 0, 4
  %2 = shufflevector <4 x double> %a, <4 x double> %b, 1, 5
  %3 = fadd <2 x double> %1, %2, exceptions=ignore
  %r3 = fadd double %b2, %b3, exceptions=ignore
  %r021 = shufflevector <2 x double> %3, <2 x double> poison, 0, 4294967295, 1, 4294967295
  %r03 = insertelement <4 x double> %r021, double %r3, i64 3
  ret <4 x double> %r03
}
Transformation doesn't verify!
ERROR: Target is more poisonous than source

Example:
<4 x double> %a = < poison, poison, poison, poison >
<4 x double> %b = < poison, poison, poison, poison >

Source:
double %a0 = poison
double %a1 = poison
double %b0 = poison
double %b1 = poison
double %b2 = poison
double %b3 = poison
double %r0 = poison
double %r2 = poison
double %r3 = poison
<4 x double> %r00 = < poison, NaN	[based on undef value], NaN, NaN >
<4 x double> %r02 = < poison, NaN, poison, NaN >
<4 x double> %r03 = < poison, NaN, poison, poison >

Target:
double %b2 = poison
double %b3 = poison
<2 x double> %1 = < poison, poison >
<2 x double> %2 = < poison, poison >
<2 x double> %3 = < poison, poison >
double %r3 = poison
<4 x double> %r021 = < poison, poison, poison, poison >
<4 x double> %r03 = < poison, poison, poison, poison >
Source value: < poison, NaN, poison, poison >
Target value: < poison, poison, poison, poison >


------------------- SMT STATS -------------------
Num queries: 85
Num invalid: 0
Num skips:   0
Num trivial: 25 (22.7%)
Num timeout: 7 (8.2%)
Num errors:  0 (0.0%)
Num SAT:     68 (80.0%)
Num UNSAT:   10 (11.8%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S
+ /tmp/nlopes/llvm/build/bin/FileCheck /tmp/nlopes/llvm/llvm/test/Transforms/SLPVectorizer/X86/hadd.ll --check-prefix=CHECK --check-prefix=SSE

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /tmp/nlopes/llvm/build/bin/FileCheck /tmp/nlopes/llvm/llvm/test/Transforms/SLPVectorizer/X86/hadd.ll --check-prefix=CHECK --check-prefix=SSE

 

<-- Back