Test Failure: Transforms/InstCombine/fdiv.ll

Test source: git

Log:

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

----------------------------------------
define float @exact_inverse(float %x) {
#0:
  %div = fdiv float %x, 8.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 3. InstCombinePass

----------------------------------------
define float @exact_inverse(float %x) {
#0:
  %div = fdiv float %x, 8.000000
  ret float %div
}
=>
define float @exact_inverse(float %x) {
#0:
  %div = fmul float %x, 0.125000
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstCombinePass

----------------------------------------
define float @exact_inverse2(float %x) {
#0:
  %div = fdiv float %x, 0.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 7. InstCombinePass

----------------------------------------
define float @exact_inverse2(float %x) {
#0:
  %div = fdiv float %x, 0.000000
  ret float %div
}
=>
define float @exact_inverse2(float %x) {
#0:
  %div = fmul float %x, 85070591730234615865843651857942052864.000000
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstCombinePass

----------------------------------------
define float @exact_inverse_but_denorm(float %x) {
#0:
  %div = fdiv float %x, 170141183460469231731687303715884105728.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 11. InstCombinePass

----------------------------------------
define float @exact_inverse_but_denorm(float %x) {
#0:
  %div = fdiv float %x, 170141183460469231731687303715884105728.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

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

----------------------------------------
define float @not_exact_inverse2(float %x) {
#0:
  %div = fdiv float %x, 0x00000001
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 15. InstCombinePass

----------------------------------------
define float @not_exact_inverse2(float %x) {
#0:
  %div = fdiv float %x, 0x00000001
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstCombinePass

----------------------------------------
define float @not_exact_but_allow_recip(float %x) {
#0:
  %div = fdiv arcp float %x, 3.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 19. InstCombinePass

----------------------------------------
define float @not_exact_but_allow_recip(float %x) {
#0:
  %div = fdiv arcp float %x, 3.000000
  ret float %div
}
=>
define float @not_exact_but_allow_recip(float %x) {
#0:
  %div = fmul arcp float %x, 0.333333
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstCombinePass

----------------------------------------
define float @not_exact_but_allow_recip_but_denorm(float %x) {
#0:
  %div = fdiv arcp float %x, 170141345719746060945050695293894393856.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 23. InstCombinePass

----------------------------------------
define float @not_exact_but_allow_recip_but_denorm(float %x) {
#0:
  %div = fdiv arcp float %x, 170141345719746060945050695293894393856.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

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

----------------------------------------
define <2 x float> @exact_inverse_splat(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 4.000000, 4.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 27. InstCombinePass

----------------------------------------
define <2 x float> @exact_inverse_splat(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 4.000000, 4.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @exact_inverse_splat(<2 x float> %x) {
#0:
  %div = fmul <2 x float> %x, { 0.250000, 0.250000 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 2 x float>
-- 30. InstCombinePass
ERROR: Unsupported type: <vscale x 2 x float>
-- 31. InstCombinePass
ERROR: Unsupported type: <vscale x 2 x float>
-- 32. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 2 x float>
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_but_allow_recip_splat(<2 x float> %x) {
#0:
  %div = fdiv arcp <2 x float> %x, { 3.000000, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 35. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_but_allow_recip_splat(<2 x float> %x) {
#0:
  %div = fdiv arcp <2 x float> %x, { 3.000000, 3.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @not_exact_but_allow_recip_splat(<2 x float> %x) {
#0:
  %div = fmul arcp <2 x float> %x, { 0.333333, 0.333333 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstCombinePass

----------------------------------------
define <2 x float> @exact_inverse_vec(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 4.000000, 8.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 39. InstCombinePass

----------------------------------------
define <2 x float> @exact_inverse_vec(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 4.000000, 8.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @exact_inverse_vec(<2 x float> %x) {
#0:
  %div = fmul <2 x float> %x, { 0.250000, 0.125000 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_splat(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 3.000000, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 43. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_splat(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 3.000000, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_vec(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 4.000000, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 47. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_vec(<2 x float> %x) {
#0:
  %div = fdiv <2 x float> %x, { 4.000000, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

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

----------------------------------------
define <2 x float> @not_exact_inverse_vec_arcp(<2 x float> %x) {
#0:
  %div = fdiv arcp <2 x float> %x, { 4.000000, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 51. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_vec_arcp(<2 x float> %x) {
#0:
  %div = fdiv arcp <2 x float> %x, { 4.000000, 3.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @not_exact_inverse_vec_arcp(<2 x float> %x) {
#0:
  %div = fmul arcp <2 x float> %x, { 0.250000, 0.333333 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_vec_arcp_with_poison_elt(<2 x float> %x) {
#0:
  %div = fdiv arcp <2 x float> %x, { poison, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 55. InstCombinePass

----------------------------------------
define <2 x float> @not_exact_inverse_vec_arcp_with_poison_elt(<2 x float> %x) {
#0:
  %div = fdiv arcp <2 x float> %x, { poison, 3.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstCombinePass

----------------------------------------
define float @div_with_div_numerator(float %x, float %y, float %z) {
#0:
  %div1 = fdiv ninf float %x, %y
  %div2 = fdiv arcp reassoc float %div1, %z
  ret float %div2
}
Transformation seems to be correct! (syntactically equal)

-- 59. InstCombinePass

----------------------------------------
define float @div_with_div_numerator(float %x, float %y, float %z) {
#0:
  %div1 = fdiv ninf float %x, %y
  %div2 = fdiv arcp reassoc float %div1, %z
  ret float %div2
}
=>
define float @div_with_div_numerator(float %x, float %y, float %z) {
#0:
  %#1 = fmul arcp reassoc float %y, %z
  %div2 = fdiv arcp reassoc float %x, %#1
  ret float %div2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstCombinePass

----------------------------------------
define <2 x float> @div_with_div_denominator(<2 x float> %x, <2 x float> %y, <2 x float> %z) {
#0:
  %div1 = fdiv nnan <2 x float> %x, %y
  %div2 = fdiv arcp reassoc <2 x float> %z, %div1
  ret <2 x float> %div2
}
Transformation seems to be correct! (syntactically equal)

-- 63. InstCombinePass

----------------------------------------
define <2 x float> @div_with_div_denominator(<2 x float> %x, <2 x float> %y, <2 x float> %z) {
#0:
  %div1 = fdiv nnan <2 x float> %x, %y
  %div2 = fdiv arcp reassoc <2 x float> %z, %div1
  ret <2 x float> %div2
}
=>
define <2 x float> @div_with_div_denominator(<2 x float> %x, <2 x float> %y, <2 x float> %z) {
#0:
  %#1 = fmul arcp reassoc <2 x float> %y, %z
  %div2 = fdiv arcp reassoc <2 x float> %#1, %x
  ret <2 x float> %div2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstCombinePass

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

define float @div_with_div_numerator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float %x, %y
  %div2 = fdiv fast float %div1, %z
  call void @use_f32(float %div1)
  ret float %div2
}
Transformation seems to be correct! (syntactically equal)

-- 67. InstCombinePass

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

define float @div_with_div_numerator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float %x, %y
  %div2 = fdiv fast float %div1, %z
  call void @use_f32(float %div1)
  ret float %div2
}
Transformation seems to be correct! (syntactically equal)

-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstCombinePass

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

define float @div_with_div_denominator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float %x, %y
  %div2 = fdiv fast float %z, %div1
  call void @use_f32(float %div1)
  ret float %div2
}
Transformation seems to be correct! (syntactically equal)

-- 71. InstCombinePass

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

define float @div_with_div_denominator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float %x, %y
  %div2 = fdiv fast float %z, %div1
  call void @use_f32(float %div1)
  ret float %div2
}
Transformation seems to be correct! (syntactically equal)

-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstCombinePass

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

define float @div_with_div_denominator_with_one_as_numerator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float 1.000000, %y
  %div2 = fdiv arcp reassoc float %z, %div1
  call void @use_f32(float %div1)
  ret float %div2
}
Transformation seems to be correct! (syntactically equal)

-- 75. InstCombinePass

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

define float @div_with_div_denominator_with_one_as_numerator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float 1.000000, %y
  %div2 = fdiv arcp reassoc float %z, %div1
  call void @use_f32(float %div1)
  ret float %div2
}
=>
declare void @use_f32(float)

define float @div_with_div_denominator_with_one_as_numerator_extra_use(float %x, float %y, float %z) {
#0:
  %div1 = fdiv float 1.000000, %y
  %div2 = fmul arcp reassoc float %y, %z
  call void @use_f32(float %div1)
  ret float %div2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstCombinePass

----------------------------------------
define float @fneg_fneg(float %x, float %y) {
#0:
  %x.fneg = fsub float -0.000000, %x
  %y.fneg = fsub float -0.000000, %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 79. InstCombinePass

----------------------------------------
define float @fneg_fneg(float %x, float %y) {
#0:
  %x.fneg = fsub float -0.000000, %x
  %y.fneg = fsub float -0.000000, %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
=>
define float @fneg_fneg(float %x, float %y) {
#0:
  %div = fdiv float %x, %y
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstCombinePass

----------------------------------------
define float @unary_fneg_unary_fneg(float %x, float %y) {
#0:
  %x.fneg = fneg float %x
  %y.fneg = fneg float %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 83. InstCombinePass

----------------------------------------
define float @unary_fneg_unary_fneg(float %x, float %y) {
#0:
  %x.fneg = fneg float %x
  %y.fneg = fneg float %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
=>
define float @unary_fneg_unary_fneg(float %x, float %y) {
#0:
  %div = fdiv float %x, %y
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass

----------------------------------------
define float @unary_fneg_fneg(float %x, float %y) {
#0:
  %x.fneg = fneg float %x
  %y.fneg = fsub float -0.000000, %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 87. InstCombinePass

----------------------------------------
define float @unary_fneg_fneg(float %x, float %y) {
#0:
  %x.fneg = fneg float %x
  %y.fneg = fsub float -0.000000, %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
=>
define float @unary_fneg_fneg(float %x, float %y) {
#0:
  %div = fdiv float %x, %y
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstCombinePass

----------------------------------------
define float @fneg_unary_fneg(float %x, float %y) {
#0:
  %x.fneg = fsub float -0.000000, %x
  %y.fneg = fneg float %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 91. InstCombinePass

----------------------------------------
define float @fneg_unary_fneg(float %x, float %y) {
#0:
  %x.fneg = fsub float -0.000000, %x
  %y.fneg = fneg float %y
  %div = fdiv float %x.fneg, %y.fneg
  ret float %div
}
=>
define float @fneg_unary_fneg(float %x, float %y) {
#0:
  %div = fdiv float %x, %y
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstCombinePass

----------------------------------------
define float @fneg_fneg_fast(float %x, float %y) {
#0:
  %x.fneg = fsub float -0.000000, %x
  %y.fneg = fsub float -0.000000, %y
  %div = fdiv fast float %x.fneg, %y.fneg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 95. InstCombinePass

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

----------------------------------------
define float @unary_fneg_unary_fneg_fast(float %x, float %y) {
#0:
  %x.fneg = fneg float %x
  %y.fneg = fneg float %y
  %div = fdiv fast float %x.fneg, %y.fneg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 99. InstCombinePass

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

----------------------------------------
define <2 x float> @fneg_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %yneg = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 103. InstCombinePass

----------------------------------------
define <2 x float> @fneg_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %yneg = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
=>
define <2 x float> @fneg_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %div = fdiv <2 x float> %x, %y
  ret <2 x float> %div
}
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_fneg_unary_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fneg <2 x float> %x
  %yneg = fneg <2 x float> %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 107. InstCombinePass

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

----------------------------------------
define <2 x float> @fneg_unary_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %yneg = fneg <2 x float> %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 111. InstCombinePass

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

----------------------------------------
define <2 x float> @unary_fneg_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fneg <2 x float> %x
  %yneg = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 115. InstCombinePass

----------------------------------------
define <2 x float> @unary_fneg_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fneg <2 x float> %x
  %yneg = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
=>
define <2 x float> @unary_fneg_fneg_vec(<2 x float> %x, <2 x float> %y) {
#0:
  %div = fdiv <2 x float> %x, %y
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstCombinePass

----------------------------------------
define <2 x float> @fneg_fneg_vec_poison_elts(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fsub <2 x float> { poison, -0.000000 }, %x
  %yneg = fsub <2 x float> { -0.000000, poison }, %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 119. InstCombinePass

----------------------------------------
define <2 x float> @fneg_fneg_vec_poison_elts(<2 x float> %x, <2 x float> %y) {
#0:
  %xneg = fsub <2 x float> { poison, -0.000000 }, %x
  %yneg = fsub <2 x float> { -0.000000, poison }, %y
  %div = fdiv <2 x float> %xneg, %yneg
  ret <2 x float> %div
}
=>
define <2 x float> @fneg_fneg_vec_poison_elts(<2 x float> %x, <2 x float> %y) {
#0:
  %div = fdiv <2 x float> %x, %y
  ret <2 x float> %div
}
Transformation seems to be correct!

-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstCombinePass

----------------------------------------
define float @fneg_dividend_constant_divisor(float %x) {
#0:
  %neg = fsub float -0.000000, %x
  %div = fdiv nsz float %neg, 3.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 123. InstCombinePass

----------------------------------------
define float @fneg_dividend_constant_divisor(float %x) {
#0:
  %neg = fsub float -0.000000, %x
  %div = fdiv nsz float %neg, 3.000000
  ret float %div
}
=>
define float @fneg_dividend_constant_divisor(float %x) {
#0:
  %div = fdiv nsz float %x, -3.000000
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstCombinePass

----------------------------------------
define float @unary_fneg_dividend_constant_divisor(float %x) {
#0:
  %neg = fneg float %x
  %div = fdiv nsz float %neg, 3.000000
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 127. InstCombinePass

----------------------------------------
define float @unary_fneg_dividend_constant_divisor(float %x) {
#0:
  %neg = fneg float %x
  %div = fdiv nsz float %neg, 3.000000
  ret float %div
}
=>
define float @unary_fneg_dividend_constant_divisor(float %x) {
#0:
  %div = fdiv nsz float %x, -3.000000
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass

----------------------------------------
define float @fneg_divisor_constant_dividend(float %x) {
#0:
  %neg = fsub float -0.000000, %x
  %div = fdiv nnan float -3.000000, %neg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 131. InstCombinePass

----------------------------------------
define float @fneg_divisor_constant_dividend(float %x) {
#0:
  %neg = fsub float -0.000000, %x
  %div = fdiv nnan float -3.000000, %neg
  ret float %div
}
=>
define float @fneg_divisor_constant_dividend(float %x) {
#0:
  %div = fdiv nnan float 3.000000, %x
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstCombinePass

----------------------------------------
define float @unary_fneg_divisor_constant_dividend(float %x) {
#0:
  %neg = fneg float %x
  %div = fdiv nnan float -3.000000, %neg
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 135. InstCombinePass

----------------------------------------
define float @unary_fneg_divisor_constant_dividend(float %x) {
#0:
  %neg = fneg float %x
  %div = fdiv nnan float -3.000000, %neg
  ret float %div
}
=>
define float @unary_fneg_divisor_constant_dividend(float %x) {
#0:
  %div = fdiv nnan float 3.000000, %x
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass

----------------------------------------
define <2 x float> @fneg_dividend_constant_divisor_vec(<2 x float> %x) {
#0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %div = fdiv ninf <2 x float> %neg, { 3.000000, -8.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 139. InstCombinePass

----------------------------------------
define <2 x float> @fneg_dividend_constant_divisor_vec(<2 x float> %x) {
#0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %div = fdiv ninf <2 x float> %neg, { 3.000000, -8.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @fneg_dividend_constant_divisor_vec(<2 x float> %x) {
#0:
  %div = fdiv ninf <2 x float> %x, { -3.000000, 8.000000 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass

----------------------------------------
define <2 x float> @unary_fneg_dividend_constant_divisor_vec(<2 x float> %x) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv ninf <2 x float> %neg, { 3.000000, -8.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 143. InstCombinePass

----------------------------------------
define <2 x float> @unary_fneg_dividend_constant_divisor_vec(<2 x float> %x) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv ninf <2 x float> %neg, { 3.000000, -8.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @unary_fneg_dividend_constant_divisor_vec(<2 x float> %x) {
#0:
  %div = fdiv ninf <2 x float> %x, { -3.000000, 8.000000 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstCombinePass

----------------------------------------
define <2 x float> @fneg_dividend_constant_divisor_vec_poison_elt(<2 x float> %x) {
#0:
  %neg = fsub <2 x float> { poison, -0.000000 }, %x
  %div = fdiv ninf <2 x float> %neg, { 3.000000, -8.000000 }
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 147. InstCombinePass

----------------------------------------
define <2 x float> @fneg_dividend_constant_divisor_vec_poison_elt(<2 x float> %x) {
#0:
  %neg = fsub <2 x float> { poison, -0.000000 }, %x
  %div = fdiv ninf <2 x float> %neg, { 3.000000, -8.000000 }
  ret <2 x float> %div
}
=>
define <2 x float> @fneg_dividend_constant_divisor_vec_poison_elt(<2 x float> %x) {
#0:
  %div = fdiv ninf <2 x float> %x, { -3.000000, 8.000000 }
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstCombinePass

----------------------------------------
define <2 x float> @fneg_divisor_constant_dividend_vec(<2 x float> %x) {
#0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %div = fdiv afn <2 x float> { -3.000000, 5.000000 }, %neg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 151. InstCombinePass

----------------------------------------
define <2 x float> @fneg_divisor_constant_dividend_vec(<2 x float> %x) {
#0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %div = fdiv afn <2 x float> { -3.000000, 5.000000 }, %neg
  ret <2 x float> %div
}
=>
define <2 x float> @fneg_divisor_constant_dividend_vec(<2 x float> %x) {
#0:
  %div = fdiv afn <2 x float> { 3.000000, -5.000000 }, %x
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstCombinePass

----------------------------------------
define <2 x float> @unary_fneg_divisor_constant_dividend_vec(<2 x float> %x) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv afn <2 x float> { -3.000000, 5.000000 }, %neg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 155. InstCombinePass

----------------------------------------
define <2 x float> @unary_fneg_divisor_constant_dividend_vec(<2 x float> %x) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv afn <2 x float> { -3.000000, 5.000000 }, %neg
  ret <2 x float> %div
}
=>
define <2 x float> @unary_fneg_divisor_constant_dividend_vec(<2 x float> %x) {
#0:
  %div = fdiv afn <2 x float> { 3.000000, -5.000000 }, %x
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstCombinePass

----------------------------------------
define float @div_factor(float %x, float %y) {
#0:
  %m = fmul float %x, %y
  %d = fdiv nnan reassoc float %x, %m
  ret float %d
}
Transformation seems to be correct! (syntactically equal)

-- 159. InstCombinePass

----------------------------------------
define float @div_factor(float %x, float %y) {
#0:
  %m = fmul float %x, %y
  %d = fdiv nnan reassoc float %x, %m
  ret float %d
}
=>
define float @div_factor(float %x, float %y) {
#0:
  %d = fdiv nnan reassoc float 1.000000, %y
  ret float %d
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
-- 162. InstCombinePass

----------------------------------------
define float @div_factor_too_strict(float %x, float %y) {
#0:
  %m = fmul float %x, %y
  %d = fdiv reassoc float %x, %m
  ret float %d
}
Transformation seems to be correct! (syntactically equal)

-- 163. InstCombinePass

----------------------------------------
define float @div_factor_too_strict(float %x, float %y) {
#0:
  %m = fmul float %x, %y
  %d = fdiv reassoc float %x, %m
  ret float %d
}
Transformation seems to be correct! (syntactically equal)

-- 164. PassManager<Function> : Skipping NOP
-- 165. PassManager<Function> : Skipping NOP
-- 166. InstCombinePass

----------------------------------------
define <2 x float> @div_factor_commute(<2 x float> %x, <2 x float> %y) {
#0:
  %m = fmul <2 x float> %y, %x
  %d = fdiv nnan ninf nsz reassoc <2 x float> %x, %m
  ret <2 x float> %d
}
Transformation seems to be correct! (syntactically equal)

-- 167. InstCombinePass

----------------------------------------
define <2 x float> @div_factor_commute(<2 x float> %x, <2 x float> %y) {
#0:
  %m = fmul <2 x float> %y, %x
  %d = fdiv nnan ninf nsz reassoc <2 x float> %x, %m
  ret <2 x float> %d
}
=>
define <2 x float> @div_factor_commute(<2 x float> %x, <2 x float> %y) {
#0:
  %d = fdiv nnan ninf nsz reassoc <2 x float> { 1.000000, 1.000000 }, %y
  ret <2 x float> %d
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend1(<2 x float> %x) {
#0:
  %t1 = fmul <2 x float> %x, { 3.000000, 7.000000 }
  %t2 = fdiv arcp reassoc <2 x float> { 15.000000, 7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 171. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend1(<2 x float> %x) {
#0:
  %t1 = fmul <2 x float> %x, { 3.000000, 7.000000 }
  %t2 = fdiv arcp reassoc <2 x float> { 15.000000, 7.000000 }, %t1
  ret <2 x float> %t2
}
=>
define <2 x float> @div_constant_dividend1(<2 x float> %x) {
#0:
  %t2 = fdiv arcp reassoc <2 x float> { 5.000000, 1.000000 }, %x
  ret <2 x float> %t2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Function> : Skipping NOP
-- 174. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend1_arcp_only(<2 x float> %x) {
#0:
  %t1 = fmul <2 x float> %x, { 3.000000, 7.000000 }
  %t2 = fdiv arcp <2 x float> { 15.000000, 7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 175. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend1_arcp_only(<2 x float> %x) {
#0:
  %t1 = fmul <2 x float> %x, { 3.000000, 7.000000 }
  %t2 = fdiv arcp <2 x float> { 15.000000, 7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend2(<2 x float> %x) {
#0:
  %t1 = fdiv <2 x float> %x, { 3.000000, -7.000000 }
  %t2 = fdiv arcp reassoc <2 x float> { 15.000000, -7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 179. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend2(<2 x float> %x) {
#0:
  %t1 = fdiv <2 x float> %x, { 3.000000, -7.000000 }
  %t2 = fdiv arcp reassoc <2 x float> { 15.000000, -7.000000 }, %t1
  ret <2 x float> %t2
}
=>
define <2 x float> @div_constant_dividend2(<2 x float> %x) {
#0:
  %t2 = fdiv arcp reassoc <2 x float> { 45.000000, 49.000000 }, %x
  ret <2 x float> %t2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend2_reassoc_only(<2 x float> %x) {
#0:
  %t1 = fdiv <2 x float> %x, { 3.000000, -7.000000 }
  %t2 = fdiv reassoc <2 x float> { 15.000000, -7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 183. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend2_reassoc_only(<2 x float> %x) {
#0:
  %t1 = fdiv <2 x float> %x, { 3.000000, -7.000000 }
  %t2 = fdiv reassoc <2 x float> { 15.000000, -7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 184. PassManager<Function> : Skipping NOP
-- 185. PassManager<Function> : Skipping NOP
-- 186. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend3(<2 x float> %x) {
#0:
  %t1 = fdiv <2 x float> { 3.000000, 7.000000 }, %x
  %t2 = fdiv arcp reassoc <2 x float> { 15.000000, -7.000000 }, %t1
  ret <2 x float> %t2
}
Transformation seems to be correct! (syntactically equal)

-- 187. InstCombinePass

----------------------------------------
define <2 x float> @div_constant_dividend3(<2 x float> %x) {
#0:
  %t1 = fdiv <2 x float> { 3.000000, 7.000000 }, %x
  %t2 = fdiv arcp reassoc <2 x float> { 15.000000, -7.000000 }, %t1
  ret <2 x float> %t2
}
=>
define <2 x float> @div_constant_dividend3(<2 x float> %x) {
#0:
  %#1 = fmul arcp reassoc <2 x float> %x, { 15.000000, -7.000000 }
  %t2 = fmul arcp reassoc <2 x float> %#1, { 0.333333, 0.142857 }
  ret <2 x float> %t2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 188. PassManager<Function> : Skipping NOP
-- 189. PassManager<Function> : Skipping NOP
-- 190. InstCombinePass

----------------------------------------
define double @fdiv_fneg1(double %x, double %y) {
#0:
  %neg = fsub double -0.000000, %x
  %div = fdiv double %neg, %y
  ret double %div
}
Transformation seems to be correct! (syntactically equal)

-- 191. InstCombinePass

----------------------------------------
define double @fdiv_fneg1(double %x, double %y) {
#0:
  %neg = fsub double -0.000000, %x
  %div = fdiv double %neg, %y
  ret double %div
}
=>
define double @fdiv_fneg1(double %x, double %y) {
#0:
  %neg = fneg double %x
  %div = fdiv double %neg, %y
  ret double %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InstCombinePass

----------------------------------------
define double @fdiv_unary_fneg1(double %x, double %y) {
#0:
  %neg = fneg double %x
  %div = fdiv double %neg, %y
  ret double %div
}
Transformation seems to be correct! (syntactically equal)

-- 195. InstCombinePass

----------------------------------------
define double @fdiv_unary_fneg1(double %x, double %y) {
#0:
  %neg = fneg double %x
  %div = fdiv double %neg, %y
  ret double %div
}
Transformation seems to be correct! (syntactically equal)

-- 196. PassManager<Function> : Skipping NOP
-- 197. PassManager<Function> : Skipping NOP
-- 198. InstCombinePass

----------------------------------------
define <2 x float> @fdiv_fneg2(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %div = fdiv <2 x float> %y, %neg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 199. InstCombinePass

----------------------------------------
define <2 x float> @fdiv_fneg2(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %div = fdiv <2 x float> %y, %neg
  ret <2 x float> %div
}
=>
define <2 x float> @fdiv_fneg2(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv <2 x float> %y, %neg
  ret <2 x float> %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 200. PassManager<Function> : Skipping NOP
-- 201. PassManager<Function> : Skipping NOP
-- 202. InstCombinePass

----------------------------------------
define <2 x float> @fdiv_unary_fneg2(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv <2 x float> %y, %neg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 203. InstCombinePass

----------------------------------------
define <2 x float> @fdiv_unary_fneg2(<2 x float> %x, <2 x float> %y) {
#0:
  %neg = fneg <2 x float> %x
  %div = fdiv <2 x float> %y, %neg
  ret <2 x float> %div
}
Transformation seems to be correct! (syntactically equal)

-- 204. PassManager<Function> : Skipping NOP
-- 205. PassManager<Function> : Skipping NOP
-- 206. InstCombinePass

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

define float @fdiv_fneg1_extra_use(float %x, float %y) {
#0:
  %neg = fsub float -0.000000, %x
  call void @use_f32(float %neg)
  %div = fdiv float %neg, %y
  ret float %div
}
Transformation seems to be correct! (syntactically equal)

-- 207. InstCombinePass

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

define float @fdiv_fneg1_extra_use(float %x, float %y) {
#0:
  %neg = fsub float -0.000000, %x
  call void @use_f32(float %neg)
  %div = fdiv float %neg, %y
  ret float %div
}
=>
declare void @use_f32(float)

define float @fdiv_fneg1_extra_use(float %x, float %y) {
#0:
  %neg = fneg float %x
  call void @use_f32(float %neg)
  %div = fdiv float %neg, %y
  ret float %div
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 208. PassManager<Function> : Skipping NOP
-- 209. PassManager<Function> : Skipping NOP
-- 210. InstCombinePass

----------------------------------------
define float @fabs_same_op(float %x) {
#0:
  %a = fabs float %x
  %r = fdiv float %a, %a
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 211. InstCombinePass

----------------------------------------
define float @fabs_same_op(float %x) {
#0:
  %a = fabs float %x
  %r = fdiv float %a, %a
  ret float %r
}
=>
define float @fabs_same_op(float %x) {
#0:
  %r = fdiv float %x, %x
  ret float %r
}
Transformation doesn't verify! (unsound)
ERROR: Value mismatch

Example:
float %x = undef

Source:
float %a = #x00000000 (+0.0)
float %r = #x7fc00000 (QNaN)

Target:
float %r = #xff800000 (-oo)
Source value: #x7fc00000 (QNaN)
Target value: #xff800000 (-oo)

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_HhJBDBuw_HGGf.bc"


------------------- SMT STATS -------------------
Num queries: 147
Num invalid: 0
Num skips:   0
Num trivial: 110 (42.8%)
Num timeout: 38 (25.9%)
Num errors:  0 (0.0%)
Num SAT:     90 (61.2%)
Num UNSAT:   19 (12.9%)
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/fdiv.ll | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fdiv.ll
+ /home/nlopes/alive2/build/opt-alive.sh -S -passes=instcombine
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fdiv.ll

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

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

<-- Back