Test Failure: Transforms/GVN/PRE/rle.ll

Test source: git

Log:

Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
ERROR: Unsupported instruction:   tail call void @llvm.memcpy.p0.p1.i64(ptr %A, ptr addrspace(1) @GCst_as1, i64 
ERROR: Unsupported attribute: noalias
ERROR: Unsupported attribute: noalias
ERROR: Unsupported attribute: noalias
ERROR: Unsupported instruction:   %tmp6.1 = load atomic i8, ptr @global acquire, align 4
-- 1. PassManager<Function> : Skipping NOP
-- 2. GVNPass

----------------------------------------
define i32 @test0(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %A = load i32, ptr %P, align 4
  ret i32 %A
}
Transformation seems to be correct! (syntactically equal)

-- 3. GVNPass

----------------------------------------
define i32 @test0(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %A = load i32, ptr %P, align 4
  ret i32 %A
}
=>
define i32 @test0(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  ret i32 %V
}
Transformation seems to be correct!

-- 4. DCEPass

----------------------------------------
define i32 @test0(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  ret i32 %V
}
Transformation seems to be correct! (syntactically equal)

-- 5. DCEPass

----------------------------------------
define i32 @test0(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  ret i32 %V
}
Transformation seems to be correct! (syntactically equal)

-- 6. PassManager<Function> : Skipping NOP
-- 7. PassManager<Function> : Skipping NOP
-- 8. GVNPass

----------------------------------------
define i8 @crash0({i32, i32} %A, ptr %P) {
#0:
  store {i32, i32} %A, ptr %P, align 4
  %Y = load i8, ptr %P, align 1
  ret i8 %Y
}
Transformation seems to be correct! (syntactically equal)

-- 9. GVNPass

----------------------------------------
define i8 @crash0({i32, i32} %A, ptr %P) {
#0:
  store {i32, i32} %A, ptr %P, align 4
  %Y = load i8, ptr %P, align 1
  ret i8 %Y
}
Transformation seems to be correct! (syntactically equal)

-- 10. DCEPass

----------------------------------------
define i8 @crash0({i32, i32} %A, ptr %P) {
#0:
  store {i32, i32} %A, ptr %P, align 4
  %Y = load i8, ptr %P, align 1
  ret i8 %Y
}
Transformation seems to be correct! (syntactically equal)

-- 11. DCEPass

----------------------------------------
define i8 @crash0({i32, i32} %A, ptr %P) {
#0:
  store {i32, i32} %A, ptr %P, align 4
  %Y = load i8, ptr %P, align 1
  ret i8 %Y
}
Transformation seems to be correct! (syntactically equal)

-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. GVNPass

----------------------------------------
declare void @helper()

@helper = constant ? bytes, align 8

define void @crash1() {
#0:
  memcpy ptr undef align 1, ptr undef align 1, i64 undef
  %ttmp = load i8, ptr @helper, align 1
  %x = icmp eq i8 %ttmp, 15
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 15. GVNPass

----------------------------------------
declare void @helper()

@helper = constant ? bytes, align 8

define void @crash1() {
#0:
  memcpy ptr undef align 1, ptr undef align 1, i64 undef
  %ttmp = load i8, ptr @helper, align 1
  %x = icmp eq i8 %ttmp, 15
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 16. DCEPass

----------------------------------------
declare void @helper()

@helper = constant ? bytes, align 8

define void @crash1() {
#0:
  memcpy ptr undef align 1, ptr undef align 1, i64 undef
  %ttmp = load i8, ptr @helper, align 1
  %x = icmp eq i8 %ttmp, 15
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 17. DCEPass

----------------------------------------
declare void @helper()

@helper = constant ? bytes, align 8

define void @crash1() {
#0:
  memcpy ptr undef align 1, ptr undef align 1, i64 undef
  %ttmp = load i8, ptr @helper, align 8
  ret void
}
=>
@helper = constant ? bytes, align 8

define void @crash1() {
#0:
  memcpy ptr undef align 1, ptr undef align 1, i64 undef
  ret void
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 18. PassManager<Function> : Skipping NOP
-- 19. PassManager<Function> : Skipping NOP
-- 20. GVNPass

----------------------------------------
define float @coerce_mustalias1(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %A = load float, ptr %P, align 4
  ret float %A
}
Transformation seems to be correct! (syntactically equal)

-- 21. GVNPass

----------------------------------------
define float @coerce_mustalias1(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %A = load float, ptr %P, align 4
  ret float %A
}
=>
define float @coerce_mustalias1(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %#1 = bitcast i32 %V to float
  ret float %#1
}
Transformation seems to be correct!

-- 22. DCEPass

----------------------------------------
define float @coerce_mustalias1(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %#1 = bitcast i32 %V to float
  ret float %#1
}
Transformation seems to be correct! (syntactically equal)

-- 23. DCEPass

----------------------------------------
define float @coerce_mustalias1(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %#1 = bitcast i32 %V to float
  ret float %#1
}
Transformation seems to be correct! (syntactically equal)

-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. GVNPass

----------------------------------------
define float @coerce_mustalias2(ptr %V, ptr %P) {
#0:
  store ptr %V, ptr %P, align 4
  %A = load float, ptr %P, align 4
  ret float %A
}
Transformation seems to be correct! (syntactically equal)

-- 27. GVNPass

----------------------------------------
define float @coerce_mustalias2(ptr %V, ptr %P) {
#0:
  store ptr %V, ptr %P, align 4
  %A = load float, ptr %P, align 4
  ret float %A
}
=>
define float @coerce_mustalias2(ptr %V, ptr %P) {
#0:
  store ptr %V, ptr %P, align 4
  %#1 = ptrtoint ptr %V to i32
  %#2 = bitcast i32 %#1 to float
  ret float %#2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 28. DCEPass

----------------------------------------
define float @coerce_mustalias2(ptr %V, ptr %P) {
#0:
  store ptr %V, ptr %P, align 4
  %#1 = ptrtoint ptr %V to i32
  %#2 = bitcast i32 %#1 to float
  ret float %#2
}
Transformation seems to be correct! (syntactically equal)

-- 29. DCEPass

----------------------------------------
define float @coerce_mustalias2(ptr %V, ptr %P) {
#0:
  store ptr %V, ptr %P, align 4
  %#1 = ptrtoint ptr %V to i32
  %#2 = bitcast i32 %#1 to float
  ret float %#2
}
Transformation seems to be correct! (syntactically equal)

-- 30. PassManager<Function> : Skipping NOP
-- 31. PassManager<Function> : Skipping NOP
-- 32. GVNPass

----------------------------------------
define ptr @coerce_mustalias3(float %V, ptr %P) {
#0:
  store float %V, ptr %P, align 4
  %A = load ptr, ptr %P, align 4
  ret ptr %A
}
Transformation seems to be correct! (syntactically equal)

-- 33. GVNPass

----------------------------------------
define ptr @coerce_mustalias3(float %V, ptr %P) {
#0:
  store float %V, ptr %P, align 4
  %A = load ptr, ptr %P, align 4
  ret ptr %A
}
=>
define ptr @coerce_mustalias3(float %V, ptr %P) {
#0:
  store float %V, ptr %P, align 4
  %#1 = bitcast float %V to i32
  %#2 = int2ptr i32 %#1 to ptr
  ret ptr %#2
}
Transformation seems to be correct!

-- 34. DCEPass

----------------------------------------
define ptr @coerce_mustalias3(float %V, ptr %P) {
#0:
  store float %V, ptr %P, align 4
  %#1 = bitcast float %V to i32
  %#2 = int2ptr i32 %#1 to ptr
  ret ptr %#2
}
Transformation seems to be correct! (syntactically equal)

-- 35. DCEPass

----------------------------------------
define ptr @coerce_mustalias3(float %V, ptr %P) {
#0:
  store float %V, ptr %P, align 4
  %#1 = bitcast float %V to i32
  %#2 = int2ptr i32 %#1 to ptr
  ret ptr %#2
}
Transformation seems to be correct! (syntactically equal)

-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. GVNPass

----------------------------------------
define float @coerce_mustalias4(ptr %P, i1 %cond) {
#0:
  %A = load i32, ptr %P, align 4
  %B = load float, ptr %P, align 4
  br i1 %cond, label %T, label %F

F:
  %X = bitcast i32 %A to float
  ret float %X

T:
  ret float %B
}
Transformation seems to be correct! (syntactically equal)

-- 39. GVNPass

----------------------------------------
define float @coerce_mustalias4(ptr %P, i1 %cond) {
#0:
  %A = load i32, ptr %P, align 4
  %B = load float, ptr %P, align 4
  br i1 %cond, label %T, label %F

F:
  %X = bitcast i32 %A to float
  ret float %X

T:
  ret float %B
}
=>
define float @coerce_mustalias4(ptr %P, i1 %cond) {
#0:
  %A = load i32, ptr %P, align 4
  %#1 = bitcast i32 %A to float
  br i1 %cond, label %T, label %F

F:
  ret float %#1

T:
  ret float %#1
}
Transformation seems to be correct!

-- 40. DCEPass

----------------------------------------
define float @coerce_mustalias4(ptr %P, i1 %cond) {
#0:
  %A = load i32, ptr %P, align 4
  %#1 = bitcast i32 %A to float
  br i1 %cond, label %T, label %F

F:
  ret float %#1

T:
  ret float %#1
}
Transformation seems to be correct! (syntactically equal)

-- 41. DCEPass

----------------------------------------
define float @coerce_mustalias4(ptr %P, i1 %cond) {
#0:
  %A = load i32, ptr %P, align 4
  %#1 = bitcast i32 %A to float
  br i1 %cond, label %T, label %F

F:
  ret float %#1

T:
  ret float %#1
}
Transformation seems to be correct! (syntactically equal)

-- 42. PassManager<Function> : Skipping NOP
-- 43. PassManager<Function> : Skipping NOP
-- 44. GVNPass

----------------------------------------
define i8 @coerce_mustalias5(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %A = load i8, ptr %P, align 1
  ret i8 %A
}
Transformation seems to be correct! (syntactically equal)

-- 45. GVNPass

----------------------------------------
define i8 @coerce_mustalias5(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %A = load i8, ptr %P, align 1
  ret i8 %A
}
=>
define i8 @coerce_mustalias5(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %#1 = trunc i32 %V to i8
  ret i8 %#1
}
Transformation seems to be correct!

-- 46. DCEPass

----------------------------------------
define i8 @coerce_mustalias5(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %#1 = trunc i32 %V to i8
  ret i8 %#1
}
Transformation seems to be correct! (syntactically equal)

-- 47. DCEPass

----------------------------------------
define i8 @coerce_mustalias5(i32 %V, ptr %P) {
#0:
  store i32 %V, ptr %P, align 4
  %#1 = trunc i32 %V to i8
  ret i8 %#1
}
Transformation seems to be correct! (syntactically equal)

-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. GVNPass

----------------------------------------
define float @coerce_mustalias6(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %A = load float, ptr %P, align 4
  ret float %A
}
Transformation seems to be correct! (syntactically equal)

-- 51. GVNPass

----------------------------------------
define float @coerce_mustalias6(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %A = load float, ptr %P, align 4
  ret float %A
}
=>
define float @coerce_mustalias6(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %#1 = trunc i64 %V to i32
  %#2 = bitcast i32 %#1 to float
  ret float %#2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 52. DCEPass

----------------------------------------
define float @coerce_mustalias6(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %#1 = trunc i64 %V to i32
  %#2 = bitcast i32 %#1 to float
  ret float %#2
}
Transformation seems to be correct! (syntactically equal)

-- 53. DCEPass

----------------------------------------
define float @coerce_mustalias6(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %#1 = trunc i64 %V to i32
  %#2 = bitcast i32 %#1 to float
  ret float %#2
}
Transformation seems to be correct! (syntactically equal)

-- 54. PassManager<Function> : Skipping NOP
-- 55. PassManager<Function> : Skipping NOP
-- 56. GVNPass

----------------------------------------
define ptr @coerce_mustalias7(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %A = load ptr, ptr %P, align 4
  ret ptr %A
}
Transformation seems to be correct! (syntactically equal)

-- 57. GVNPass

----------------------------------------
define ptr @coerce_mustalias7(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %A = load ptr, ptr %P, align 4
  ret ptr %A
}
=>
define ptr @coerce_mustalias7(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %#1 = trunc i64 %V to i32
  %#2 = int2ptr i32 %#1 to ptr
  ret ptr %#2
}
Transformation seems to be correct!

-- 58. DCEPass

----------------------------------------
define ptr @coerce_mustalias7(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %#1 = trunc i64 %V to i32
  %#2 = int2ptr i32 %#1 to ptr
  ret ptr %#2
}
Transformation seems to be correct! (syntactically equal)

-- 59. DCEPass

----------------------------------------
define ptr @coerce_mustalias7(i64 %V, ptr %P) {
#0:
  store i64 %V, ptr %P, align 4
  %#1 = trunc i64 %V to i32
  %#2 = int2ptr i32 %#1 to ptr
  ret ptr %#2
}
Transformation seems to be correct! (syntactically equal)

-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. GVNPass

----------------------------------------
define i16 @memset_to_i16_local(ptr %A) signext {
entry:
  memset ptr %A align 1, i8 1, i64 200
  %arrayidx = gep inbounds ptr %A, 2 x i64 42
  %ttmp2 = load i16, ptr %arrayidx, align 2
  ret i16 %ttmp2
}
Transformation seems to be correct! (syntactically equal)

-- 63. GVNPass

----------------------------------------
define i16 @memset_to_i16_local(ptr %A) signext {
entry:
  memset ptr %A align 1, i8 1, i64 200
  %arrayidx = gep inbounds ptr %A, 2 x i64 42
  %ttmp2 = load i16, ptr %arrayidx, align 2
  ret i16 %ttmp2
}
=>
define i16 @memset_to_i16_local(ptr %A) signext {
entry:
  memset ptr %A align 1, i8 1, i64 200
  ret i16 257
}
Transformation seems to be correct!

-- 64. DCEPass

----------------------------------------
define i16 @memset_to_i16_local(ptr %A) signext {
entry:
  memset ptr %A align 1, i8 1, i64 200
  %arrayidx = gep inbounds ptr %A, 2 x i64 42
  ret i16 257
}
Transformation seems to be correct! (syntactically equal)

-- 65. DCEPass

----------------------------------------
define i16 @memset_to_i16_local(ptr %A) signext {
entry:
  memset ptr %A align 1, i8 1, i64 200
  ret i16 257
}
=>
define i16 @memset_to_i16_local(ptr %A) signext {
entry:
  memset ptr %A align 1, i8 1, i64 200
  ret i16 257
}
Transformation seems to be correct!

-- 66. PassManager<Function> : Skipping NOP
-- 67. PassManager<Function> : Skipping NOP
-- 68. GVNPass

----------------------------------------
define float @memset_to_float_local(ptr %A, i8 %Val) {
entry:
  memset ptr %A align 1, i8 %Val, i64 400
  %arrayidx = gep inbounds ptr %A, 4 x i64 42
  %ttmp2 = load float, ptr %arrayidx, align 4
  ret float %ttmp2
}
Transformation seems to be correct! (syntactically equal)

-- 69. GVNPass

----------------------------------------
define float @memset_to_float_local(ptr %A, i8 %Val) {
entry:
  memset ptr %A align 1, i8 %Val, i64 400
  %arrayidx = gep inbounds ptr %A, 4 x i64 42
  %ttmp2 = load float, ptr %arrayidx, align 4
  ret float %ttmp2
}
=>
define float @memset_to_float_local(ptr %A, i8 %Val) {
entry:
  memset ptr %A align 1, i8 %Val, i64 400
  %#0 = zext i8 %Val to i32
  %#1 = shl i32 %#0, 8
  %#2 = or i32 %#0, %#1
  %#3 = shl i32 %#2, 16
  %#4 = or i32 %#2, %#3
  %#5 = bitcast i32 %#4 to float
  ret float %#5
}
Transformation doesn't verify! (unsound)
ERROR: Value mismatch

Example:
ptr %A = pointer(non-local, block_id=1, offset=0) / Address=#x008
i8 %Val = undef

Source:
ptr %arrayidx = pointer(non-local, block_id=1, offset=168) / Address=#x0b0
float %ttmp2 = #x00000000 (+0.0)	[based on undef value]

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0	alive: false	address: 0
Block 1 >	size: 2050	align: 8	alloc type: 0	alive: true	address: 8

Target:
i32 %#0 = #x00000000 (0)
i32 %#1 = #x00000000 (0)
i32 %#2 = #x00000000 (0)
i32 %#3 = #x00000000 (0)
i32 %#4 = #x00000800 (2048)
float %#5 = #x00000800 (0.000000000000?)
Source value: #x00000000 (+0.0)
Target value: #x00000800 (0.000000000000?)

Pass: GVNPass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-data-layout=e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32' '-passes=gvn,dce' '-enable-split-backedge-in-load-pre' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_jZqvUTqO_Pc9d.bc"


------------------- SMT STATS -------------------
Num queries: 80
Num invalid: 0
Num skips:   0
Num trivial: 50 (38.5%)
Num timeout: 2 (2.5%)
Num errors:  0 (0.0%)
Num SAT:     38 (47.5%)
Num UNSAT:   40 (50.0%)
Alive2: Transform doesn't verify; aborting!

stderr:

RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/GVN/PRE/rle.ll -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -passes=gvn,dce -enable-split-backedge-in-load-pre -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/GVN/PRE/rle.ll --check-prefixes=CHECK,LE
+ /home/nlopes/alive2/build/opt-alive.sh -data-layout=e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32 -passes=gvn,dce -enable-split-backedge-in-load-pre -S
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/GVN/PRE/rle.ll --check-prefixes=CHECK,LE

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/GVN/PRE/rle.ll --check-prefixes=CHECK,LE

NOTE: This test would pass if undef didn't exist!

<-- Back