Test Failure: Transforms/InstCombine/fmul.ll

Test source: git

Log:

Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
ERROR: Unsupported type: <vscale x 2 x float>
ERROR: Unsupported type: <vscale x 2 x float>
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstCombinePass

----------------------------------------
define float @neg_constant(float %x) {
#0:
  %sub = fsub float -0.000000, %x
  %mul = fmul ninf float %sub, 20.000000
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 3. InstCombinePass

----------------------------------------
define float @neg_constant(float %x) {
#0:
  %sub = fsub float -0.000000, %x
  %mul = fmul ninf float %sub, 20.000000
  ret float %mul
}
=>
define float @neg_constant(float %x) {
#0:
  %mul = fmul ninf float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstCombinePass

----------------------------------------
define float @unary_neg_constant(float %x) {
#0:
  %sub = fneg float %x
  %mul = fmul ninf float %sub, 20.000000
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 7. InstCombinePass

----------------------------------------
define float @unary_neg_constant(float %x) {
#0:
  %sub = fneg float %x
  %mul = fmul ninf float %sub, 20.000000
  ret float %mul
}
=>
define float @unary_neg_constant(float %x) {
#0:
  %mul = fmul ninf float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstCombinePass

----------------------------------------
define <2 x float> @neg_constant_vec(<2 x float> %x) {
#0:
  %sub = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 11. InstCombinePass

----------------------------------------
define <2 x float> @neg_constant_vec(<2 x float> %x) {
#0:
  %sub = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_constant_vec(<2 x float> %x) {
#0:
  %mul = fmul ninf <2 x float> %x, { -2.000000, -3.000000 }
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_constant_vec(<2 x float> %x) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 15. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_constant_vec(<2 x float> %x) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_constant_vec(<2 x float> %x) {
#0:
  %mul = fmul ninf <2 x float> %x, { -2.000000, -3.000000 }
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstCombinePass

----------------------------------------
define <2 x float> @neg_constant_vec_poison(<2 x float> %x) {
#0:
  %sub = fsub <2 x float> { poison, -0.000000 }, %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 19. InstCombinePass

----------------------------------------
define <2 x float> @neg_constant_vec_poison(<2 x float> %x) {
#0:
  %sub = fsub <2 x float> { poison, -0.000000 }, %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_constant_vec_poison(<2 x float> %x) {
#0:
  %mul = fmul ninf <2 x float> %x, { -2.000000, -3.000000 }
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstCombinePass

----------------------------------------
define float @neg_nsz_constant(float %x) {
#0:
  %sub = fsub nsz float 0.000000, %x
  %mul = fmul nnan float %sub, 20.000000
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 23. InstCombinePass

----------------------------------------
define float @neg_nsz_constant(float %x) {
#0:
  %sub = fsub nsz float 0.000000, %x
  %mul = fmul nnan float %sub, 20.000000
  ret float %mul
}
=>
define float @neg_nsz_constant(float %x) {
#0:
  %mul = fmul nnan float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstCombinePass

----------------------------------------
define float @unary_neg_nsz_constant(float %x) {
#0:
  %sub = fneg nsz float %x
  %mul = fmul nnan float %sub, 20.000000
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 27. InstCombinePass

----------------------------------------
define float @unary_neg_nsz_constant(float %x) {
#0:
  %sub = fneg nsz float %x
  %mul = fmul nnan float %sub, 20.000000
  ret float %mul
}
=>
define float @unary_neg_nsz_constant(float %x) {
#0:
  %mul = fmul nnan float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstCombinePass

----------------------------------------
define float @neg_neg(float %x, float %y) {
#0:
  %sub1 = fsub float -0.000000, %x
  %sub2 = fsub float -0.000000, %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 31. InstCombinePass

----------------------------------------
define float @neg_neg(float %x, float %y) {
#0:
  %sub1 = fsub float -0.000000, %x
  %sub2 = fsub float -0.000000, %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @neg_neg(float %x, float %y) {
#0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstCombinePass

----------------------------------------
define float @unary_neg_unary_neg(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %sub2 = fneg float %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 35. InstCombinePass

----------------------------------------
define float @unary_neg_unary_neg(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %sub2 = fneg float %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @unary_neg_unary_neg(float %x, float %y) {
#0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstCombinePass

----------------------------------------
define float @unary_neg_neg(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %sub2 = fsub float -0.000000, %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 39. InstCombinePass

----------------------------------------
define float @unary_neg_neg(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %sub2 = fsub float -0.000000, %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @unary_neg_neg(float %x, float %y) {
#0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstCombinePass

----------------------------------------
define float @neg_unary_neg(float %x, float %y) {
#0:
  %sub1 = fsub float -0.000000, %x
  %sub2 = fneg float %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 43. InstCombinePass

----------------------------------------
define float @neg_unary_neg(float %x, float %y) {
#0:
  %sub1 = fsub float -0.000000, %x
  %sub2 = fneg float %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @neg_unary_neg(float %x, float %y) {
#0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstCombinePass

----------------------------------------
define <2 x float> @neg_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 47. InstCombinePass

----------------------------------------
define <2 x float> @neg_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fneg <2 x float> %x
  %sub2 = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 51. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fneg <2 x float> %x
  %sub2 = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fneg <2 x float> %x
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 55. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fneg <2 x float> %x
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstCombinePass

----------------------------------------
define <2 x float> @neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %sub2 = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 59. InstCombinePass

----------------------------------------
define <2 x float> @neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %sub2 = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstCombinePass

----------------------------------------
define <2 x float> @neg_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fsub <2 x float> { -0.000000, poison }, %x
  %sub2 = fsub <2 x float> { poison, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 63. InstCombinePass

----------------------------------------
define <2 x float> @neg_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub1 = fsub <2 x float> { -0.000000, poison }, %x
  %sub2 = fsub <2 x float> { poison, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation seems to be correct!

-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fneg <2 x float> %x
  %sub = fsub <2 x float> { poison, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %neg, %sub
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 67. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fneg <2 x float> %x
  %sub = fsub <2 x float> { poison, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %neg, %sub
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstCombinePass

----------------------------------------
define <2 x float> @neg_unary_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fsub <2 x float> { -0.000000, poison }, %x
  %neg = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub, %neg
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 71. InstCombinePass

----------------------------------------
define <2 x float> @neg_unary_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fsub <2 x float> { -0.000000, poison }, %x
  %neg = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub, %neg
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_unary_neg_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstCombinePass

----------------------------------------
define float @neg_neg_nsz(float %x, float %y) {
#0:
  %sub1 = fsub nsz float 0.000000, %x
  %sub2 = fsub nsz float 0.000000, %y
  %mul = fmul afn float %sub1, %sub2
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 75. InstCombinePass

----------------------------------------
define float @neg_neg_nsz(float %x, float %y) {
#0:
  %sub1 = fsub nsz float 0.000000, %x
  %sub2 = fsub nsz float 0.000000, %y
  %mul = fmul afn float %sub1, %sub2
  ret float %mul
}
=>
define float @neg_neg_nsz(float %x, float %y) {
#0:
  %mul = fmul afn float %x, %y
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @neg_neg_multi_use(float %x, float %y) {
#0:
  %nx = fsub float -0.000000, %x
  %ny = fsub float -0.000000, %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 79. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @neg_neg_multi_use(float %x, float %y) {
#0:
  %nx = fsub float -0.000000, %x
  %ny = fsub float -0.000000, %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
declare void @use_f32(float)

define float @neg_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @unary_neg_unary_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 83. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @unary_neg_unary_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
declare void @use_f32(float)

define float @unary_neg_unary_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @unary_neg_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fsub float -0.000000, %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 87. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @unary_neg_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fsub float -0.000000, %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
declare void @use_f32(float)

define float @unary_neg_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @neg_unary_neg_multi_use(float %x, float %y) {
#0:
  %nx = fsub float -0.000000, %x
  %ny = fneg float %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 91. InstCombinePass

----------------------------------------
declare void @use_f32(float)

define float @neg_unary_neg_multi_use(float %x, float %y) {
#0:
  %nx = fsub float -0.000000, %x
  %ny = fneg float %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
declare void @use_f32(float)

define float @neg_unary_neg_multi_use(float %x, float %y) {
#0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstCombinePass

----------------------------------------
define float @neg_mul(float %x, float %y) {
#0:
  %sub = fsub float -0.000000, %x
  %mul = fmul float %sub, %y
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 95. InstCombinePass

----------------------------------------
define float @neg_mul(float %x, float %y) {
#0:
  %sub = fsub float -0.000000, %x
  %mul = fmul float %sub, %y
  ret float %mul
}
=>
define float @neg_mul(float %x, float %y) {
#0:
  %sub = fneg float %x
  %mul = fmul float %y, %sub
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstCombinePass

----------------------------------------
define float @unary_neg_mul(float %x, float %y) {
#0:
  %neg = fneg float %x
  %mul = fmul float %neg, %y
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 99. InstCombinePass

----------------------------------------
define float @unary_neg_mul(float %x, float %y) {
#0:
  %neg = fneg float %x
  %mul = fmul float %neg, %y
  ret float %mul
}
=>
define float @unary_neg_mul(float %x, float %y) {
#0:
  %neg = fneg float %x
  %mul = fmul float %y, %neg
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. InstCombinePass

----------------------------------------
define <2 x float> @neg_mul_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 103. InstCombinePass

----------------------------------------
define <2 x float> @neg_mul_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_mul_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %y, %sub
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_mul_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 107. InstCombinePass

----------------------------------------
define <2 x float> @unary_neg_mul_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_mul_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %y, %sub
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstCombinePass

----------------------------------------
define <2 x float> @neg_mul_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fsub <2 x float> { poison, -0.000000 }, %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 111. InstCombinePass

----------------------------------------
define <2 x float> @neg_mul_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fsub <2 x float> { poison, -0.000000 }, %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_mul_vec_poison(<2 x float> %x, <2 x float> %y) {
#0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %y, %sub
  ret <2 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 112. PassManager<Function> : Skipping NOP
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstCombinePass

----------------------------------------
define float @neg_sink_nsz(float %x, float %y) {
#0:
  %sub1 = fsub nsz float 0.000000, %x
  %mul = fmul float %sub1, %y
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 115. InstCombinePass

----------------------------------------
define float @neg_sink_nsz(float %x, float %y) {
#0:
  %sub1 = fsub nsz float 0.000000, %x
  %mul = fmul float %sub1, %y
  ret float %mul
}
=>
define float @neg_sink_nsz(float %x, float %y) {
#0:
  %sub1 = fneg nsz float %x
  %mul = fmul float %y, %sub1
  ret float %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstCombinePass

----------------------------------------
define float @neg_sink_multi_use(float %x, float %y) {
#0:
  %sub1 = fsub float -0.000000, %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
Transformation seems to be correct! (syntactically equal)

-- 119. InstCombinePass

----------------------------------------
define float @neg_sink_multi_use(float %x, float %y) {
#0:
  %sub1 = fsub float -0.000000, %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
=>
define float @neg_sink_multi_use(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %mul = fmul float %y, %sub1
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstCombinePass

----------------------------------------
define float @unary_neg_mul_multi_use(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
Transformation seems to be correct! (syntactically equal)

-- 123. InstCombinePass

----------------------------------------
define float @unary_neg_mul_multi_use(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
=>
define float @unary_neg_mul_multi_use(float %x, float %y) {
#0:
  %sub1 = fneg float %x
  %mul = fmul float %y, %sub1
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstCombinePass

----------------------------------------
define void @test8(ptr %inout, i1 %c1) {
entry:
  %#0 = load i32, ptr %inout, align 4
  %conv = uitofp i32 %#0 to float
  %vecinit = insertelement <4 x float> { 0.000000, 0.000000, 0.000000, poison }, float %conv, i32 3
  %sub = fsub <4 x float> { -0.000000, -0.000000, -0.000000, -0.000000 }, %vecinit
  %#1 = shufflevector <4 x float> %sub, <4 x float> poison, 1, 1, 1, 1
  %mul = fmul <4 x float> { 0.000000, 0.000000, 0.000000, 0.000000 }, %#1
  br label %for.cond

for.cond:
  %local_var_7.0 = phi <4 x float> [ %mul, %entry ], [ %#2, %for.body ]
  br i1 %c1, label %for.body, label %for.end

for.body:
  %#2 = insertelement <4 x float> %local_var_7.0, float 0.000000, i32 2
  br label %for.cond

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 127. InstCombinePass

----------------------------------------
define void @test8(ptr %inout, i1 %c1) {
entry:
  %#0 = load i32, ptr %inout, align 4
  %conv = uitofp i32 %#0 to float
  %vecinit = insertelement <4 x float> { 0.000000, 0.000000, 0.000000, poison }, float %conv, i32 3
  %sub = fsub <4 x float> { -0.000000, -0.000000, -0.000000, -0.000000 }, %vecinit
  %#1 = shufflevector <4 x float> %sub, <4 x float> poison, 1, 1, 1, 1
  %mul = fmul <4 x float> { 0.000000, 0.000000, 0.000000, 0.000000 }, %#1
  br label %for.cond

for.cond:
  %local_var_7.0 = phi <4 x float> [ %mul, %entry ], [ %#2, %for.body ]
  br i1 %c1, label %for.body, label %for.end

for.body:
  %#2 = insertelement <4 x float> %local_var_7.0, float 0.000000, i32 2
  br label %for.cond

for.end:
  ret void
}
=>
define void @test8(ptr %inout, i1 %c1) {
entry:
  br label %for.cond

for.cond:
  %local_var_7.0 = phi <4 x float> [ { -0.000000, -0.000000, -0.000000, -0.000000 }, %entry ], [ %#0, %for.body ]
  br i1 %c1, label %for.body, label %for.end

for.body:
  %#0 = insertelement <4 x float> %local_var_7.0, float 0.000000, i64 2
  br label %for.cond

for.end:
  ret void
}
Transformation seems to be correct!

-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass

----------------------------------------
define float @test9(float %x) {
#0:
  %mul = fmul float %x, -1.000000
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 131. InstCombinePass

----------------------------------------
define float @test9(float %x) {
#0:
  %mul = fmul float %x, -1.000000
  ret float %mul
}
=>
define float @test9(float %x) {
#0:
  %mul = fneg float %x
  ret float %mul
}
Transformation seems to be correct!

-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstCombinePass

----------------------------------------
define <4 x float> @test10(<4 x float> %x) {
#0:
  %mul = fmul arcp afn <4 x float> %x, { -1.000000, -1.000000, -1.000000, -1.000000 }
  ret <4 x float> %mul
}
Transformation seems to be correct! (syntactically equal)

-- 135. InstCombinePass

----------------------------------------
define <4 x float> @test10(<4 x float> %x) {
#0:
  %mul = fmul arcp afn <4 x float> %x, { -1.000000, -1.000000, -1.000000, -1.000000 }
  ret <4 x float> %mul
}
=>
define <4 x float> @test10(<4 x float> %x) {
#0:
  %mul = fneg arcp afn <4 x float> %x
  ret <4 x float> %mul
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass

----------------------------------------
define float @test11(float %x, float %y) {
#0:
  %a = fadd fast float %x, 1.000000
  %b = fadd fast float %y, 2.000000
  %c = fadd fast float %a, %b
  ret float %c
}
Transformation seems to be correct! (syntactically equal)

-- 139. InstCombinePass

----------------------------------------
define float @test11(float %x, float %y) {
#0:
  %a = fadd fast float %x, 1.000000
  %b = fadd fast float %y, 2.000000
  %c = fadd fast float %a, %b
  ret float %c
}
=>
define float @test11(float %x, float %y) {
#0:
  %b = fadd fast float %x, %y
  %c = fadd fast float %b, 3.000000
  ret float %c
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass

----------------------------------------
define double @sqrt_squared2(double %f) {
#0:
  %sqrt = sqrt double %f
  %mul1 = fmul fast double %sqrt, %sqrt
  %mul2 = fmul double %mul1, %sqrt
  ret double %mul2
}
Transformation seems to be correct! (syntactically equal)

-- 143. InstCombinePass

----------------------------------------
define double @sqrt_squared2(double %f) {
#0:
  %sqrt = sqrt double %f
  %mul1 = fmul fast double %sqrt, %sqrt
  %mul2 = fmul double %mul1, %sqrt
  ret double %mul2
}
=>
define double @sqrt_squared2(double %f) {
#0:
  %sqrt = sqrt double %f
  %mul2 = fmul double %f, %sqrt
  ret double %mul2
}
Transformation doesn't verify! (not unsound)
ERROR: SMT Error: smt-canceled
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstCombinePass

----------------------------------------
define float @fabs_squared(float %x) {
#0:
  %x.fabs = fabs float %x
  %mul = fmul float %x.fabs, %x.fabs
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)

-- 147. InstCombinePass

----------------------------------------
define float @fabs_squared(float %x) {
#0:
  %x.fabs = fabs float %x
  %mul = fmul float %x.fabs, %x.fabs
  ret float %mul
}
=>
define float @fabs_squared(float %x) {
#0:
  %mul = fmul float %x, %x
  ret float %mul
}
Transformation doesn't verify! (unsound)
ERROR: Value mismatch

Example:
float %x = undef

Source:
float %x.fabs = #x00000000 (+0.0)
float %mul = #x00000000 (+0.0)

Target:
float %mul = #x80000000 (-0.0)
Source value: #x00000000 (+0.0)
Target value: #x80000000 (-0.0)

Pass: InstCombinePass
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' '-S' '-passes=instcombine' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_l9aHfOdk_fwLu.bc"


------------------- SMT STATS -------------------
Num queries: 146
Num invalid: 0
Num skips:   0
Num trivial: 103 (41.4%)
Num timeout: 33 (22.6%)
Num errors:  1 (0.7%)
Num SAT:     86 (58.9%)
Num UNSAT:   26 (17.8%)
Alive2: Transform doesn't verify; aborting!

stderr:

RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh -S -passes=instcombine < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll
+ /home/nlopes/alive2/build/opt-alive.sh -S -passes=instcombine
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll

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

<-- Back