Test Failure: Transforms/InstCombine/fneg.ll

Test source: git

Log:

Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstCombinePass

----------------------------------------
define float @fneg_fneg(float %a) {
%0:
  %f = fneg float %a, exceptions=ignore
  %r = fneg float %f, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 3. InstCombinePass

----------------------------------------
define float @fneg_fneg(float %a) {
%0:
  %f = fneg float %a, exceptions=ignore
  %r = fneg float %f, exceptions=ignore
  ret float %r
}
=>
define float @fneg_fneg(float %a) {
%0:
  ret float %a
}
Transformation seems to be correct!

-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstCombinePass

----------------------------------------
define float @fmul_fsub(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %m, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 7. InstCombinePass

----------------------------------------
define float @fmul_fsub(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fsub(float %x) {
%0:
  %r = fmul float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!

-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstCombinePass

----------------------------------------
define float @fmul_fneg(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 11. InstCombinePass

----------------------------------------
define float @fmul_fneg(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fneg(float %x) {
%0:
  %r = fmul float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstCombinePass

----------------------------------------
define float @fmul_fsub_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub nsz reassoc float -0.000000, %m, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 15. InstCombinePass

----------------------------------------
define float @fmul_fsub_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub nsz reassoc float -0.000000, %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fsub_fmf(float %x) {
%0:
  %r = fmul nsz reassoc float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstCombinePass

----------------------------------------
define float @fmul_fneg_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg nsz reassoc float %m, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 19. InstCombinePass

----------------------------------------
define float @fmul_fneg_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg nsz reassoc float %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fneg_fmf(float %x) {
%0:
  %r = fmul nsz reassoc float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - reassoc

-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstCombinePass

----------------------------------------
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 23. InstCombinePass

----------------------------------------
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
=>
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstCombinePass

----------------------------------------
define float @fmul_fneg_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 27. InstCombinePass

----------------------------------------
define float @fmul_fneg_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstCombinePass

----------------------------------------
define <4 x double> @fmul_fsub_vec(<4 x double> %x) {
%0:
  %m = fmul <4 x double> %x, { 42.000000, 0x7ff8000000000000, inf, undef }, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %m, exceptions=ignore
  ret <4 x double> %r
}
Transformation seems to be correct! (syntactically equal)

-- 31. InstCombinePass

----------------------------------------
define <4 x double> @fmul_fsub_vec(<4 x double> %x) {
%0:
  %m = fmul <4 x double> %x, { 42.000000, 0x7ff8000000000000, inf, undef }, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %m, exceptions=ignore
  ret <4 x double> %r
}
=>
define <4 x double> @fmul_fsub_vec(<4 x double> %x) {
%0:
  %r = fmul <4 x double> %x, { -42.000000, 0xfff8000000000000, -inf, undef }, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstCombinePass

----------------------------------------
define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
%0:
  %m = fmul <4 x double> %x, { 42.000000, 0x7ff8000000000000, inf, undef }, exceptions=ignore
  %r = fneg <4 x double> %m, exceptions=ignore
  ret <4 x double> %r
}
Transformation seems to be correct! (syntactically equal)

-- 35. InstCombinePass

----------------------------------------
define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
%0:
  %m = fmul <4 x double> %x, { 42.000000, 0x7ff8000000000000, inf, undef }, exceptions=ignore
  %r = fneg <4 x double> %m, exceptions=ignore
  ret <4 x double> %r
}
=>
define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
%0:
  %r = fmul <4 x double> %x, { -42.000000, 0xfff8000000000000, -inf, undef }, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fsub(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 39. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fsub(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub(float %x) {
%0:
  %r = fdiv float %x, 42.000000, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!

-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fneg(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 43. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fneg(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op1_constant_fneg(float %x) {
%0:
  %r = fdiv float %x, 42.000000, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fsub_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fsub nnan float -0.000000, %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 47. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fsub_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fsub nnan float -0.000000, %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub_fmf(float %x) {
%0:
  %r = fdiv nnan float %x, 42.000000, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!

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

----------------------------------------
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 51. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %r = fdiv nnan float %x, 42.000000, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!

-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 55. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 59. InstCombinePass

----------------------------------------
define float @fdiv_op1_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

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

----------------------------------------
define <4 x double> @fdiv_op1_constant_fsub_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> %x, { -42.000000, 0xfff800000abcd000, -inf, undef }, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d, exceptions=ignore
  ret <4 x double> %r
}
Transformation seems to be correct! (syntactically equal)

-- 63. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op1_constant_fsub_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> %x, { -42.000000, 0xfff800000abcd000, -inf, undef }, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d, exceptions=ignore
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op1_constant_fsub_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> %x, { 42.000000, 0x7ff800000abcd000, inf, undef }, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> %x, { -42.000000, 0xfff800000abcd000, -inf, undef }, exceptions=ignore
  %r = fneg <4 x double> %d, exceptions=ignore
  ret <4 x double> %r
}
Transformation seems to be correct! (syntactically equal)

-- 67. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> %x, { -42.000000, 0xfff800000abcd000, -inf, undef }, exceptions=ignore
  %r = fneg <4 x double> %d, exceptions=ignore
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> %x, { 42.000000, 0x7ff800000abcd000, inf, undef }, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fsub(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 71. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fsub(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fsub(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 75. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
%0:
  %d = fdiv fast float 42.000000, %x, exceptions=ignore
  %r = fneg fast float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 79. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
%0:
  %d = fdiv fast float 42.000000, %x, exceptions=ignore
  %r = fneg fast float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
%0:
  %r = fdiv fast float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_fast(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg fast float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 83. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_fast(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg fast float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast(float %x) {
%0:
  %r = fdiv nnan arcp contract reassoc afn float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
%0:
  %d = fdiv nsz float 42.000000, %x, exceptions=ignore
  %r = fneg nsz float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 87. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
%0:
  %d = fdiv nsz float 42.000000, %x, exceptions=ignore
  %r = fneg nsz float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
%0:
  %r = fdiv nsz float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nsz(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg nsz float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 91. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nsz(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg nsz float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
%0:
  %d = fdiv ninf float 42.000000, %x, exceptions=ignore
  %r = fneg ninf float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 95. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
%0:
  %d = fdiv ninf float 42.000000, %x, exceptions=ignore
  %r = fneg ninf float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
%0:
  %r = fdiv ninf float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg ninf float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 99. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg ninf float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
%0:
  %d = fdiv nnan float 42.000000, %x, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 103. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
%0:
  %d = fdiv nnan float 42.000000, %x, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
%0:
  %r = fdiv nnan float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nnan(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 107. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_nnan(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan(float %x) {
%0:
  %r = fdiv nnan float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 111. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
=>
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 112. PassManager<Function> : Skipping NOP
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 115. InstCombinePass

----------------------------------------
define float @fdiv_op0_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op0_constant_fsub_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> { -42.000000, 0x7ff8000000000000, -inf, undef }, %x, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d, exceptions=ignore
  ret <4 x double> %r
}
Transformation seems to be correct! (syntactically equal)

-- 119. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op0_constant_fsub_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> { -42.000000, 0x7ff8000000000000, -inf, undef }, %x, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d, exceptions=ignore
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op0_constant_fsub_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> { 42.000000, 0xfff8000000000000, inf, undef }, %x, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> { -42.000000, 0x7ff8000000000000, -inf, undef }, %x, exceptions=ignore
  %r = fneg <4 x double> %d, exceptions=ignore
  ret <4 x double> %r
}
Transformation seems to be correct! (syntactically equal)

-- 123. InstCombinePass

----------------------------------------
define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> { -42.000000, 0x7ff8000000000000, -inf, undef }, %x, exceptions=ignore
  %r = fneg <4 x double> %d, exceptions=ignore
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> { 42.000000, 0xfff8000000000000, inf, undef }, %x, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstCombinePass

----------------------------------------
define <2 x double> @fneg_fneg_sel(<2 x double> %x, <2 x double> %y, i1 %cond) {
%0:
  %n1 = fneg <2 x double> %x, exceptions=ignore
  %n2 = fneg <2 x double> %y, exceptions=ignore
  %sel = select i1 %cond, <2 x double> %n1, <2 x double> %n2
  ret <2 x double> %sel
}
Transformation seems to be correct! (syntactically equal)

-- 127. InstCombinePass

----------------------------------------
define <2 x double> @fneg_fneg_sel(<2 x double> %x, <2 x double> %y, i1 %cond) {
%0:
  %n1 = fneg <2 x double> %x, exceptions=ignore
  %n2 = fneg <2 x double> %y, exceptions=ignore
  %sel = select i1 %cond, <2 x double> %n1, <2 x double> %n2
  ret <2 x double> %sel
}
=>
define <2 x double> @fneg_fneg_sel(<2 x double> %x, <2 x double> %y, i1 %cond) {
%0:
  %sel.v = select i1 %cond, <2 x double> %x, <2 x double> %y
  %sel = fneg <2 x double> %sel.v, exceptions=ignore
  ret <2 x double> %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass

----------------------------------------
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)

-- 131. InstCombinePass

----------------------------------------
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  call void @use(float %n1)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v, exceptions=ignore
  ret float %sel
}
Transformation seems to be correct!

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

----------------------------------------
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  %n2 = fneg float %y, exceptions=ignore
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)

-- 135. InstCombinePass

----------------------------------------
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  %n2 = fneg float %y, exceptions=ignore
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
%0:
  %n2 = fneg float %y, exceptions=ignore
  call void @use(float %n2)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v, exceptions=ignore
  ret float %sel
}
Transformation seems to be correct!

-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass

----------------------------------------
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fsub float -0.000000, %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fsub float -0.000000, %y, exceptions=ignore
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)

-- 139. InstCombinePass

----------------------------------------
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fsub float -0.000000, %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fsub float -0.000000, %y, exceptions=ignore
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  call void @use(float %n1)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v, exceptions=ignore
  ret float %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass

----------------------------------------
define float @fneg_fneg_sel_extra_use3(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)

-- 143. InstCombinePass

----------------------------------------
define float @fneg_fneg_sel_extra_use3(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)

-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf1(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select i1 %cond, double %n1, double %n2
  ret double %sel
}
Transformation seems to be correct! (syntactically equal)

-- 147. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf1(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf1(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select i1 %cond, double %x, double %y
  %sel = fneg double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!

-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf2(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan ninf double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select i1 %cond, double %n1, double %n2
  ret double %sel
}
Transformation seems to be correct! (syntactically equal)

-- 151. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf2(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan ninf double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf2(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select ninf i1 %cond, double %x, double %y
  %sel = fneg ninf double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!

-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf3(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan ninf double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select ninf i1 %cond, double %n1, double %n2
  ret double %sel
}
Transformation seems to be correct! (syntactically equal)

-- 155. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf3(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan ninf double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select ninf i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf3(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select ninf i1 %cond, double %x, double %y
  %sel = fneg ninf double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!

-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf4(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select nnan ninf nsz i1 %cond, double %n1, double %n2
  ret double %sel
}
Transformation seems to be correct! (syntactically equal)

-- 159. InstCombinePass

----------------------------------------
define double @fneg_fneg_sel_fmf4(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select nnan ninf nsz i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf4(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select nnan ninf nsz i1 %cond, double %x, double %y
  %sel = fneg nnan ninf nsz double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
-- 162. InstCombinePass

----------------------------------------
define float @fneg_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 163. InstCombinePass

----------------------------------------
define float @fneg_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

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

----------------------------------------
define float @fake_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 167. InstCombinePass

----------------------------------------
define float @fake_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
define float @fake_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg float %a, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InstCombinePass

----------------------------------------
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 171. InstCombinePass

----------------------------------------
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
=>
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %r = fsub nsz float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Function> : Skipping NOP
-- 174. InstCombinePass

----------------------------------------
define float @fake_fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fsub fast float -0.000000, %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 175. InstCombinePass

----------------------------------------
define float @fake_fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fsub fast float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant(float %x) {
%0:
  %r = fsub fast float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstCombinePass

----------------------------------------
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 179. InstCombinePass

----------------------------------------
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstCombinePass

----------------------------------------
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fsub fast float -0.000000, %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 183. InstCombinePass

----------------------------------------
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fsub fast float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fneg fast float %a, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 184. PassManager<Function> : Skipping NOP
-- 185. PassManager<Function> : Skipping NOP
-- 186. InstCombinePass

----------------------------------------
define <2 x float> @fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %a = fadd <2 x float> %x, { 42.000000, 43.000000 }, exceptions=ignore
  %r = fneg nnan nsz reassoc <2 x float> %a, exceptions=ignore
  ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)

-- 187. InstCombinePass

----------------------------------------
define <2 x float> @fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %a = fadd <2 x float> %x, { 42.000000, 43.000000 }, exceptions=ignore
  %r = fneg nnan nsz reassoc <2 x float> %a, exceptions=ignore
  ret <2 x float> %r
}
=>
define <2 x float> @fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %r = fsub nnan nsz reassoc <2 x float> { -42.000000, -43.000000 }, %x, exceptions=ignore
  ret <2 x float> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 188. PassManager<Function> : Skipping NOP
-- 189. PassManager<Function> : Skipping NOP
-- 190. InstCombinePass

----------------------------------------
define <2 x float> @fake_fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %a = fadd <2 x float> %x, { 42.000000, undef }, exceptions=ignore
  %r = fsub nsz <2 x float> { undef, -0.000000 }, %a, exceptions=ignore
  ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)

-- 191. InstCombinePass

----------------------------------------
define <2 x float> @fake_fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %a = fadd <2 x float> %x, { 42.000000, undef }, exceptions=ignore
  %r = fsub nsz <2 x float> { undef, -0.000000 }, %a, exceptions=ignore
  ret <2 x float> %r
}
=>
define <2 x float> @fake_fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %r = fsub nsz <2 x float> { -42.000000, undef }, %x, exceptions=ignore
  ret <2 x float> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InstCombinePass

----------------------------------------
@g = global 2 bytes, align 1

define float @fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 195. InstCombinePass

----------------------------------------
@g = global 2 bytes, align 1

define float @fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

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

----------------------------------------
@g = global 2 bytes, align 1

define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fsub nsz float -0.000000, %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 199. InstCombinePass

----------------------------------------
@g = global 2 bytes, align 1

define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fsub nsz float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
@g = global 2 bytes, align 1

define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 200. PassManager<Function> : Skipping NOP
-- 201. PassManager<Function> : Skipping NOP
-- 202. InstCombinePass

----------------------------------------
define float @select_fneg_true(float %x, float %y, i1 %b) {
%0:
  %nx = fneg float %x, exceptions=ignore
  %s = select i1 %b, float %nx, float %y
  %r = fneg float %s, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 203. InstCombinePass

----------------------------------------
define float @select_fneg_true(float %x, float %y, i1 %b) {
%0:
  %nx = fneg float %x, exceptions=ignore
  %s = select i1 %b, float %nx, float %y
  %r = fneg float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_fneg_true(float %x, float %y, i1 %b) {
%0:
  %y.neg = fneg float %y, exceptions=ignore
  %r = select i1 %b, float %x, float %y.neg
  ret float %r
}
Transformation seems to be correct!

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

----------------------------------------
define <2 x float> @select_fneg_false(<2 x float> %x, <2 x float> %y, <2 x i1> %b) {
%0:
  %ny = fneg nnan <2 x float> %y, exceptions=ignore
  %s = select ninf <2 x i1> %b, <2 x float> %x, <2 x float> %ny
  %r = fneg nnan nsz <2 x float> %s, exceptions=ignore
  ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)

-- 207. InstCombinePass

----------------------------------------
define <2 x float> @select_fneg_false(<2 x float> %x, <2 x float> %y, <2 x i1> %b) {
%0:
  %ny = fneg nnan <2 x float> %y, exceptions=ignore
  %s = select ninf <2 x i1> %b, <2 x float> %x, <2 x float> %ny
  %r = fneg nnan nsz <2 x float> %s, exceptions=ignore
  ret <2 x float> %r
}
=>
define <2 x float> @select_fneg_false(<2 x float> %x, <2 x float> %y, <2 x i1> %b) {
%0:
  %x.neg = fneg nnan nsz <2 x float> %x, exceptions=ignore
  %r = select nnan ninf <2 x i1> %b, <2 x float> %x.neg, <2 x float> %y
  ret <2 x float> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 208. PassManager<Function> : Skipping NOP
-- 209. PassManager<Function> : Skipping NOP
-- 210. InstCombinePass

----------------------------------------
define float @select_fneg_false_no_nsz(float %x, float %y, i1 %b) {
%0:
  %ny = fneg float %y, exceptions=ignore
  %s = select i1 %b, float %x, float %ny
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 211. InstCombinePass

----------------------------------------
define float @select_fneg_false_no_nsz(float %x, float %y, i1 %b) {
%0:
  %ny = fneg float %y, exceptions=ignore
  %s = select i1 %b, float %x, float %ny
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_fneg_false_no_nsz(float %x, float %y, i1 %b) {
%0:
  %x.neg = fneg nnan ninf nsz float %x, exceptions=ignore
  %r = select nnan ninf i1 %b, float %x.neg, float %y
  ret float %r
}
Transformation seems to be correct!

-- 212. PassManager<Function> : Skipping NOP
-- 213. PassManager<Function> : Skipping NOP
-- 214. InstCombinePass

----------------------------------------
define float @select_fneg_false_nsz_ok(float %x, float %y, i1 noundef %b) {
%0:
  %ny = fneg float %y, exceptions=ignore
  %s = select i1 noundef %b, float %x, float %ny
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 215. InstCombinePass

----------------------------------------
define float @select_fneg_false_nsz_ok(float %x, float %y, i1 noundef %b) {
%0:
  %ny = fneg float %y, exceptions=ignore
  %s = select i1 noundef %b, float %x, float %ny
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_fneg_false_nsz_ok(float %x, float %y, i1 noundef %b) {
%0:
  %x.neg = fneg nnan ninf nsz float %x, exceptions=ignore
  %r = select nnan ninf nsz i1 noundef %b, float %x.neg, float %y
  ret float %r
}
Transformation seems to be correct!

-- 216. PassManager<Function> : Skipping NOP
-- 217. PassManager<Function> : Skipping NOP
-- 218. InstCombinePass

----------------------------------------
define float @select_fneg_false_nsz(float %x, float %y, i1 %b) {
%0:
  %ny = fneg float %y, exceptions=ignore
  %s = select nsz i1 %b, float %x, float %ny
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 219. InstCombinePass

----------------------------------------
define float @select_fneg_false_nsz(float %x, float %y, i1 %b) {
%0:
  %ny = fneg float %y, exceptions=ignore
  %s = select nsz i1 %b, float %x, float %ny
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_fneg_false_nsz(float %x, float %y, i1 %b) {
%0:
  %x.neg = fneg nnan ninf nsz float %x, exceptions=ignore
  %r = select nnan ninf nsz i1 %b, float %x.neg, float %y
  ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 220. PassManager<Function> : Skipping NOP
-- 221. PassManager<Function> : Skipping NOP
-- 222. InstCombinePass

----------------------------------------
define float @select_common_op_fneg_true(float %x, i1 %b) {
%0:
  %nx = fneg float %x, exceptions=ignore
  %s = select i1 %b, float %x, float %nx
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 223. InstCombinePass

----------------------------------------
define float @select_common_op_fneg_true(float %x, i1 %b) {
%0:
  %nx = fneg float %x, exceptions=ignore
  %s = select i1 %b, float %x, float %nx
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_common_op_fneg_true(float %x, i1 %b) {
%0:
  %x.neg = fneg nnan ninf nsz float %x, exceptions=ignore
  %r = select nnan ninf nsz i1 %b, float %x.neg, float %x
  ret float %r
}
Transformation seems to be correct!

-- 224. PassManager<Function> : Skipping NOP
-- 225. PassManager<Function> : Skipping NOP
-- 226. InstCombinePass

----------------------------------------
define float @select_common_op_fneg_false(float %x, i1 %b) {
%0:
  %nx = fneg float %x, exceptions=ignore
  %s = select i1 %b, float %x, float %nx
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
Transformation seems to be correct! (syntactically equal)

-- 227. InstCombinePass

----------------------------------------
define float @select_common_op_fneg_false(float %x, i1 %b) {
%0:
  %nx = fneg float %x, exceptions=ignore
  %s = select i1 %b, float %x, float %nx
  %r = fneg nnan ninf nsz float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_common_op_fneg_false(float %x, i1 %b) {
%0:
  %x.neg = fneg nnan ninf nsz float %x, exceptions=ignore
  %r = select nnan ninf nsz i1 %b, float %x.neg, float %x
  ret float %r
}
Transformation seems to be correct!

-- 228. PassManager<Function> : Skipping NOP
-- 229. PassManager<Function> : Skipping NOP
-- 230. InstCombinePass

----------------------------------------
define float @fabs(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp ogt float %a, %fneg
  %sel = select i1 %cmp, float %fneg, float %a
  %fneg1 = fneg nnan ninf nsz float %sel, exceptions=ignore
  ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)

-- 231. InstCombinePass

----------------------------------------
define float @fabs(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp ogt float %a, %fneg
  %sel = select i1 %cmp, float %fneg, float %a
  %fneg1 = fneg nnan ninf nsz float %sel, exceptions=ignore
  ret float %fneg1
}
=>
define float @fabs(float %a) {
%0:
  %1 = fabs nnan ninf nsz float %a, exceptions=ignore
  ret float %1
}
Transformation seems to be correct!

-- 232. PassManager<Function> : Skipping NOP
-- 233. PassManager<Function> : Skipping NOP
-- 234. InstCombinePass

----------------------------------------
define float @fnabs(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp olt float %a, %fneg
  %sel = select i1 %cmp, float %fneg, float %a
  %fneg1 = fneg fast float %sel, exceptions=ignore
  ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)

-- 235. InstCombinePass

----------------------------------------
define float @fnabs(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp olt float %a, %fneg
  %sel = select i1 %cmp, float %fneg, float %a
  %fneg1 = fneg fast float %sel, exceptions=ignore
  ret float %fneg1
}
=>
define float @fnabs(float %a) {
%0:
  %1 = fabs fast float %a, exceptions=ignore
  %fneg1 = fneg fast float %1, exceptions=ignore
  ret float %fneg1
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - afn
 - arcp
 - contract
 - reassoc

-- 236. PassManager<Function> : Skipping NOP
-- 237. PassManager<Function> : Skipping NOP
-- 238. InstCombinePass

----------------------------------------
define float @fnabs_1(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp ogt float %a, %fneg
  %sel = select i1 %cmp, float %a, float %fneg
  %fneg1 = fneg fast float %sel, exceptions=ignore
  ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)

-- 239. InstCombinePass

----------------------------------------
define float @fnabs_1(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp ogt float %a, %fneg
  %sel = select i1 %cmp, float %a, float %fneg
  %fneg1 = fneg fast float %sel, exceptions=ignore
  ret float %fneg1
}
=>
define float @fnabs_1(float %a) {
%0:
  %1 = fabs fast float %a, exceptions=ignore
  %fneg1 = fneg fast float %1, exceptions=ignore
  ret float %fneg1
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - afn
 - arcp
 - contract
 - reassoc

-- 240. PassManager<Function> : Skipping NOP
-- 241. PassManager<Function> : Skipping NOP
-- 242. InstCombinePass

----------------------------------------
define float @fnabs_2_nsz(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp olt float %a, %fneg
  %sel = select nsz i1 %cmp, float %fneg, float %a
  %fneg1 = fneg float %sel, exceptions=ignore
  ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)

-- 243. InstCombinePass

----------------------------------------
define float @fnabs_2_nsz(float %a) {
%0:
  %fneg = fneg float %a, exceptions=ignore
  %cmp = fcmp olt float %a, %fneg
  %sel = select nsz i1 %cmp, float %fneg, float %a
  %fneg1 = fneg float %sel, exceptions=ignore
  ret float %fneg1
}
=>
define float @fnabs_2_nsz(float %a) {
%0:
  %1 = fabs nsz float %a, exceptions=ignore
  %fneg1 = fneg float %1, exceptions=ignore
  ret float %fneg1
}
Transformation doesn't verify! (unsound)
ERROR: Value mismatch

Example:
float %a = #xff808000 (QNaN)

Source:
float %fneg = #x7f808000 (QNaN)
i1 %cmp = #x0 (0)
float %sel = #xff808000 (QNaN)
float %fneg1 = #x7f808000 (QNaN)

Target:
float %1 = #x7f808000 (QNaN)
float %fneg1 = #xff808000 (QNaN)
Source value: #x7f808000 (QNaN)
Target value: #xff808000 (QNaN)

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' '-passes=instcombine' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'


------------------- SMT STATS -------------------
Num queries: 270
Num invalid: 0
Num skips:   0
Num trivial: 141 (34.3%)
Num timeout: 34 (12.6%)
Num errors:  0 (0.0%)
Num SAT:     166 (61.5%)
Num UNSAT:   70 (25.9%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

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

<-- Back