Test Failure: Transforms/VectorCombine/load-insert-store.ll

Test source: git

Log:

Source: <stdin>
ERROR: Unsupported type: <vscale x 8 x i16>
ERROR: Unsupported instruction:   %0 = load <vscale x 8 x i16>, <vscale x 8 x i16>* %q, align 16
ERROR: Unsupported instruction:   store volatile <16 x i8> %vecins0, <16 x i8>* %q, align 16
ERROR: Unsupported attribute: noalias

----------------------------------------
define void @insert_store(* %q, i8 %s) {
%entry:
  %0 = load <16 x i8>, * %q, align 16
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 3
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store(* %q, i8 %s) {
%entry:
  %0 = gep inbounds * %q, 16 x i32 0, 1 x i32 3
  store i8 %s, * %0, align 1
  ret void
}
Transformation seems to be correct!


----------------------------------------
define void @insert_store_i16_align1(* %q, i16 %s) {
%entry:
  %0 = load <8 x i16>, * %q, align 16
  %vecins = insertelement <8 x i16> %0, i16 %s, i32 3
  store <8 x i16> %vecins, * %q, align 1
  ret void
}
=>
define void @insert_store_i16_align1(* %q, i16 %s) {
%entry:
  %0 = gep inbounds * %q, 16 x i32 0, 2 x i32 3
  store i16 %s, * %0, align 2
  ret void
}
Transformation seems to be correct!


----------------------------------------
define void @insert_store_outofbounds(* %q, i16 %s) {
%entry:
  %0 = load <8 x i16>, * %q, align 16
  %vecins = insertelement <8 x i16> %0, i16 %s, i32 9
  store <8 x i16> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_outofbounds(* %q, i16 %s) {
%entry:
  %0 = load <8 x i16>, * %q, align 16
  %vecins = insertelement <8 x i16> %0, i16 %s, i32 9
  store <8 x i16> %vecins, * %q, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

ERROR: Unsupported type: <vscale x 8 x i16>
ERROR: Unsupported instruction:   %0 = load <vscale x 8 x i16>, <vscale x 8 x i16>* %q, align 16

----------------------------------------
define void @insert_store_v9i4(* %q, i4 %s) {
%entry:
  %0 = load <9 x i4>, * %q, align 16
  %vecins = insertelement <9 x i4> %0, i4 %s, i32 3
  store <9 x i4> %vecins, * %q, align 1
  ret void
}
=>
define void @insert_store_v9i4(* %q, i4 %s) {
%entry:
  %0 = load <9 x i4>, * %q, align 16
  %vecins = insertelement <9 x i4> %0, i4 %s, i32 3
  store <9 x i4> %vecins, * %q, align 1
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @insert_store_v4i27(* %q, i27 %s) {
%entry:
  %0 = load <4 x i27>, * %q, align 16
  %vecins = insertelement <4 x i27> %0, i27 %s, i32 3
  store <4 x i27> %vecins, * %q, align 1
  ret void
}
=>
define void @insert_store_v4i27(* %q, i27 %s) {
%entry:
  %0 = load <4 x i27>, * %q, align 16
  %vecins = insertelement <4 x i27> %0, i27 %s, i32 3
  store <4 x i27> %vecins, * %q, align 1
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @insert_store_blk_differ(* %q, i16 %s) {
%entry:
  %0 = load <8 x i16>, * %q, align 16
  br label %cont

%cont:
  %vecins = insertelement <8 x i16> %0, i16 %s, i32 3
  store <8 x i16> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_blk_differ(* %q, i16 %s) {
%entry:
  %0 = load <8 x i16>, * %q, align 16
  br label %cont

%cont:
  %vecins = insertelement <8 x i16> %0, i16 %s, i32 3
  store <8 x i16> %vecins, * %q, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @insert_store_nonconst(* %q, i8 %s, i32 %idx) {
%entry:
  %0 = load <16 x i8>, * %q, align 16
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_nonconst(* %q, i8 %s, i32 %idx) {
%entry:
  %0 = load <16 x i8>, * %q, align 16
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @insert_store_nonconst_large_alignment(* %q, i32 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 4
  assume i1 %cmp
  %i = load <4 x i32>, * %q, align 128
  %vecins = insertelement <4 x i32> %i, i32 %s, i32 %idx
  store <4 x i32> %vecins, * %q, align 128
  ret void
}
=>
define void @insert_store_nonconst_large_alignment(* %q, i32 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 4
  assume i1 %cmp
  %0 = gep inbounds * %q, 16 x i32 0, 4 x i32 %idx
  store i32 %s, * %0, align 4
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @insert_store_nonconst_align_maximum_8(* %q, i64 %s, i32 %idx) {
%0:
  %cmp = icmp ult i32 %idx, 2
  assume i1 %cmp
  %i = load <8 x i64>, * %q, align 8
  %vecins = insertelement <8 x i64> %i, i64 %s, i32 %idx
  store <8 x i64> %vecins, * %q, align 8
  ret void
}
=>
define void @insert_store_nonconst_align_maximum_8(* %q, i64 %s, i32 %idx) {
%0:
  %cmp = icmp ult i32 %idx, 2
  assume i1 %cmp
  %1 = gep inbounds * %q, 64 x i32 0, 8 x i32 %idx
  store i64 %s, * %1, align 8
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @insert_store_nonconst_align_maximum_4(* %q, i64 %s, i32 %idx) {
%0:
  %cmp = icmp ult i32 %idx, 2
  assume i1 %cmp
  %i = load <8 x i64>, * %q, align 4
  %vecins = insertelement <8 x i64> %i, i64 %s, i32 %idx
  store <8 x i64> %vecins, * %q, align 4
  ret void
}
=>
define void @insert_store_nonconst_align_maximum_4(* %q, i64 %s, i32 %idx) {
%0:
  %cmp = icmp ult i32 %idx, 2
  assume i1 %cmp
  %1 = gep inbounds * %q, 64 x i32 0, 8 x i32 %idx
  store i64 %s, * %1, align 4
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @insert_store_nonconst_align_larger(* %q, i64 %s, i32 %idx) {
%0:
  %cmp = icmp ult i32 %idx, 2
  assume i1 %cmp
  %i = load <8 x i64>, * %q, align 4
  %vecins = insertelement <8 x i64> %i, i64 %s, i32 %idx
  store <8 x i64> %vecins, * %q, align 2
  ret void
}
=>
define void @insert_store_nonconst_align_larger(* %q, i64 %s, i32 %idx) {
%0:
  %cmp = icmp ult i32 %idx, 2
  assume i1 %cmp
  %1 = gep inbounds * %q, 64 x i32 0, 8 x i32 %idx
  store i64 %s, * %1, align 4
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @insert_store_nonconst_index_known_valid_by_assume(* %q, i8 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 4
  assume i1 %cmp
  %0 = load <16 x i8>, * %q, align 16
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_nonconst_index_known_valid_by_assume(* %q, i8 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 4
  assume i1 %cmp
  %0 = gep inbounds * %q, 16 x i32 0, 1 x i32 %idx
  store i8 %s, * %0, align 1
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @insert_store_nonconst_index_not_known_valid_by_assume_after_load(* %q, i8 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 4
  %0 = load <16 x i8>, * %q, align 16
  call void @maythrow() noread nowrite nofree
  assume i1 %cmp
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_nonconst_index_not_known_valid_by_assume_after_load(* %q, i8 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 4
  %0 = load <16 x i8>, * %q, align 16
  call void @maythrow() noread nowrite nofree
  assume i1 %cmp
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @insert_store_nonconst_index_not_known_valid_by_assume(* %q, i8 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 17
  assume i1 %cmp
  %0 = load <16 x i8>, * %q, align 16
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_nonconst_index_not_known_valid_by_assume(* %q, i8 %s, i32 %idx) {
%entry:
  %cmp = icmp ult i32 %idx, 17
  assume i1 %cmp
  %0 = load <16 x i8>, * %q, align 16
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @insert_store_nonconst_index_known_valid_by_and(* %q, i8 %s, i32 %idx) {
%entry:
  %0 = load <16 x i8>, * %q, align 16
  %idx.clamped = and i32 %idx, 7
  %vecins = insertelement <16 x i8> %0, i8 %s, i32 %idx.clamped
  store <16 x i8> %vecins, * %q, align 16
  ret void
}
=>
define void @insert_store_nonconst_index_known_valid_by_and(* %q, i8 %s, i32 %idx) {
%entry:
  %idx.clamped = and i32 %idx, 7
  %0 = gep inbounds * %q, 16 x i32 0, 1 x i32 %idx.clamped
  store i8 %s, * %0, align 1
  ret void
}
Transformation doesn't verify!
ERROR: Source is more defined than target

Example:
* %q = pointer(non-local, block_id=1, offset=30064771072)
i8 %s = poison
i32 %idx = poison

Source:
<16 x i8> %0 = < poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison >
i32 %idx.clamped = poison
<16 x i8> %vecins = < poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison, poison >

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0
Block 1 >	size: 34359738368	align: 16	alloc type: 0

Target:
i32 %idx.clamped = poison
* %0 = poison



------------------- SMT STATS -------------------
Num queries: 60
Num invalid: 0
Num skips:   0
Num trivial: 29 (32.6%)
Num timeout: 5 (8.3%)
Num errors:  0 (0.0%)
Num SAT:     46 (76.7%)
Num UNSAT:   9 (15.0%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -S -vector-combine -data-layout=e
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/VectorCombine/load-insert-store.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/VectorCombine/load-insert-store.ll

<-- Back