Test Failure: Transforms/VectorCombine/X86/load.ll

Test source: git

Comments: LLVM PR44185

Log:

Source: <stdin>

----------------------------------------
define float @matching_fp_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %r = load float, * dereferenceable(16) align(16) %p, align 16
  ret float %r
}
=>
define float @matching_fp_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %r = load float, * dereferenceable(16) align(16) %p, align 16
  ret float %r
}
Transformation seems to be correct!

ERROR: Unsupported instruction:   %r = load volatile float, float* %p, align 16
ERROR: Unsupported instruction:   %r = load volatile float, float* %p, align 16

----------------------------------------
define double @larger_fp_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load double, * %bc, align 16
  ret double %r
}
=>
define double @larger_fp_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load double, * %bc, align 16
  ret double %r
}
Transformation seems to be correct!


----------------------------------------
define float @smaller_fp_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load float, * %bc, align 16
  ret float %r
}
=>
define float @smaller_fp_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load float, * %bc, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_vector(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load float, * %bc, align 16
  ret float %r
}
=>
define float @matching_fp_vector(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load float, * %bc, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_vector_gep00(* dereferenceable(16) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(16) align(16) %p, 16 x i64 0, 4 x i64 0
  %r = load float, * %gep, align 16
  ret float %r
}
=>
define float @matching_fp_vector_gep00(* dereferenceable(16) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(16) align(16) %p, 16 x i64 0, 4 x i64 0
  %r = load float, * %gep, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_vector_gep01(* dereferenceable(20) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(20) align(16) %p, 16 x i64 0, 4 x i64 1
  %r = load float, * %gep, align 4
  ret float %r
}
=>
define float @matching_fp_vector_gep01(* dereferenceable(20) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(20) align(16) %p, 16 x i64 0, 4 x i64 1
  %r = load float, * %gep, align 4
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_vector_gep01_deref(* dereferenceable(19) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(19) align(16) %p, 16 x i64 0, 4 x i64 1
  %r = load float, * %gep, align 4
  ret float %r
}
=>
define float @matching_fp_vector_gep01_deref(* dereferenceable(19) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(19) align(16) %p, 16 x i64 0, 4 x i64 1
  %r = load float, * %gep, align 4
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_vector_gep10(* dereferenceable(32) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(32) align(16) %p, 16 x i64 1, 4 x i64 0
  %r = load float, * %gep, align 16
  ret float %r
}
=>
define float @matching_fp_vector_gep10(* dereferenceable(32) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(32) align(16) %p, 16 x i64 1, 4 x i64 0
  %r = load float, * %gep, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_vector_gep10_deref(* dereferenceable(31) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(31) align(16) %p, 16 x i64 1, 4 x i64 0
  %r = load float, * %gep, align 16
  ret float %r
}
=>
define float @matching_fp_vector_gep10_deref(* dereferenceable(31) align(16) %p) {
%0:
  %gep = gep inbounds * dereferenceable(31) align(16) %p, 16 x i64 1, 4 x i64 0
  %r = load float, * %gep, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @nonmatching_int_vector(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load float, * %bc, align 16
  ret float %r
}
=>
define float @nonmatching_int_vector(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load float, * %bc, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define double @less_aligned(* dereferenceable(16) align(4) %p) {
%0:
  %r = load double, * dereferenceable(16) align(4) %p, align 4
  ret double %r
}
=>
define double @less_aligned(* dereferenceable(16) align(4) %p) {
%0:
  %r = load double, * dereferenceable(16) align(4) %p, align 4
  ret double %r
}
Transformation seems to be correct!


----------------------------------------
define float @matching_fp_scalar_small_deref(* dereferenceable(15) align(16) %p) {
%0:
  %r = load float, * dereferenceable(15) align(16) %p, align 16
  ret float %r
}
=>
define float @matching_fp_scalar_small_deref(* dereferenceable(15) align(16) %p) {
%0:
  %r = load float, * dereferenceable(15) align(16) %p, align 16
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define i64 @larger_int_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load i64, * %bc, align 16
  ret i64 %r
}
=>
define i64 @larger_int_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load i64, * %bc, align 16
  ret i64 %r
}
Transformation seems to be correct!


----------------------------------------
define i8 @smaller_int_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load i8, * %bc, align 16
  ret i8 %r
}
=>
define i8 @smaller_int_scalar(* dereferenceable(16) align(16) %p) {
%0:
  %bc = bitcast * dereferenceable(16) align(16) %p to *
  %r = load i8, * %bc, align 16
  ret i8 %r
}
Transformation seems to be correct!


----------------------------------------
define double @larger_fp_scalar_256bit_vec(* dereferenceable(32) align(32) %p) {
%0:
  %bc = bitcast * dereferenceable(32) align(32) %p to *
  %r = load double, * %bc, align 32
  ret double %r
}
=>
define double @larger_fp_scalar_256bit_vec(* dereferenceable(32) align(32) %p) {
%0:
  %bc = bitcast * dereferenceable(32) align(32) %p to *
  %r = load double, * %bc, align 32
  ret double %r
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @load_f32_insert_v4f32(* dereferenceable(16) align(16) %p) {
%0:
  %s = load float, * dereferenceable(16) align(16) %p, align 4
  %r = insertelement <4 x float> undef, float %s, i32 0
  ret <4 x float> %r
}
=>
define <4 x float> @load_f32_insert_v4f32(* dereferenceable(16) align(16) %p) {
%0:
  %1 = bitcast * dereferenceable(16) align(16) %p to *
  %r = load <4 x float>, * %1, align 4
  ret <4 x float> %r
}
Transformation doesn't verify!
ERROR: Target is more poisonous than source

Example:
* dereferenceable(16) align(16) %p = pointer(non-local, block_id=1, offset=96)

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

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

Target:
* %1 = pointer(non-local, block_id=1, offset=96)
<4 x float> %r = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
Source value: < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0) >
Target value: < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >


------------------- SMT STATS -------------------
Num queries: 34
Num invalid: 0
Num skips:   0
Num trivial: 76 (69.1%)
Num timeout: 1 (2.9%)
Num errors:  0 (0.0%)
Num SAT:     17 (50.0%)
Num UNSAT:   16 (47.1%)

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes//alive2/build/scripts/opt-alive.sh -vector-combine -S -mtriple=x86_64-- -mattr=sse2
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/VectorCombine/X86/load.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/VectorCombine/X86/load.ll

<-- Back