Test source: git
Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
ERROR: Unsupported metadata: 41
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstCombinePass
----------------------------------------
define float @fneg_fneg(float %a) {
#0:
%f = fneg float %a
%r = fneg float %f
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 3. InstCombinePass
----------------------------------------
define float @fneg_fneg(float %a) {
#0:
%f = fneg float %a
%r = fneg float %f
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
%r = fsub float -0.000000, %m
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
%r = fsub float -0.000000, %m
ret float %r
}
=>
define float @fmul_fsub(float %x) {
#0:
%r = fmul float %x, -42.000000
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
%r = fneg float %m
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
%r = fneg float %m
ret float %r
}
=>
define float @fmul_fneg(float %x) {
#0:
%r = fmul float %x, -42.000000
ret float %r
}
Transformation seems to be correct!
-- 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
%r = fsub nsz reassoc float -0.000000, %m
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
%r = fsub nsz reassoc float -0.000000, %m
ret float %r
}
=>
define float @fmul_fsub_fmf(float %x) {
#0:
%r = fmul nsz reassoc float %x, -42.000000
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
%r = fneg nsz reassoc float %m
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
%r = fneg nsz reassoc float %m
ret float %r
}
=>
define float @fmul_fneg_fmf(float %x) {
#0:
%r = fmul nsz reassoc float %x, -42.000000
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
----------------------------------------
declare void @use(float)
define float @fmul_fsub_extra_use(float %x) {
#0:
%m = fmul float %x, 42.000000
%r = fsub float -0.000000, %m
call void @use(float %m)
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 23. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fmul_fsub_extra_use(float %x) {
#0:
%m = fmul float %x, 42.000000
%r = fsub float -0.000000, %m
call void @use(float %m)
ret float %r
}
=>
declare void @use(float)
define float @fmul_fsub_extra_use(float %x) {
#0:
%m = fmul float %x, 42.000000
%r = fneg float %m
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
----------------------------------------
declare void @use(float)
define float @fmul_fneg_extra_use(float %x) {
#0:
%m = fmul float %x, 42.000000
%r = fneg float %m
call void @use(float %m)
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 27. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fmul_fneg_extra_use(float %x) {
#0:
%m = fmul float %x, 42.000000
%r = fneg float %m
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, poison }
%r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %m
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, poison }
%r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %m
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, poison }
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, poison }
%r = fneg <4 x double> %m
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, poison }
%r = fneg <4 x double> %m
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, poison }
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
%r = fsub float -0.000000, %d
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
%r = fsub float -0.000000, %d
ret float %r
}
=>
define float @fdiv_op1_constant_fsub(float %x) {
#0:
%r = fdiv float %x, 42.000000
ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 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
%r = fneg float %d
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
%r = fneg float %d
ret float %r
}
=>
define float @fdiv_op1_constant_fneg(float %x) {
#0:
%r = fdiv float %x, 42.000000
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
%r = fsub nnan float -0.000000, %d
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
%r = fsub nnan float -0.000000, %d
ret float %r
}
=>
define float @fdiv_op1_constant_fsub_fmf(float %x) {
#0:
%r = fdiv nnan float %x, 42.000000
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
%r = fneg nnan float %d
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
%r = fneg nnan float %d
ret float %r
}
=>
define float @fdiv_op1_constant_fneg_fmf(float %x) {
#0:
%r = fdiv nnan float %x, 42.000000
ret float %r
}
Transformation seems to be correct!
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
#0:
%d = fdiv float %x, 42.000000
%r = fsub float -0.000000, %d
call void @use(float %d)
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 55. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
#0:
%d = fdiv float %x, 42.000000
%r = fsub float -0.000000, %d
call void @use(float %d)
ret float %r
}
=>
declare void @use(float)
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
#0:
%d = fdiv float %x, 42.000000
%r = fneg float %d
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
----------------------------------------
declare void @use(float)
define float @fdiv_op1_constant_fneg_extra_use(float %x) {
#0:
%d = fdiv float %x, 42.000000
%r = fneg float %d
call void @use(float %d)
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 59. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fdiv_op1_constant_fneg_extra_use(float %x) {
#0:
%d = fdiv float %x, 42.000000
%r = fneg float %d
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, poison }
%r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d
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, poison }
%r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d
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, poison }
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, poison }
%r = fneg <4 x double> %d
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, poison }
%r = fneg <4 x double> %d
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, poison }
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
%r = fsub float -0.000000, %d
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
%r = fsub float -0.000000, %d
ret float %r
}
=>
define float @fdiv_op0_constant_fsub(float %x) {
#0:
%r = fdiv float -42.000000, %x
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
%r = fneg float %d
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
%r = fneg float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg(float %x) {
#0:
%r = fdiv float -42.000000, %x
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
%r = fneg fast float %d
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
%r = fneg fast float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
#0:
%r = fdiv fast float -42.000000, %x
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
%r = fneg fast float %d
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
%r = fneg fast float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast(float %x) {
#0:
%r = fdiv nnan arcp contract reassoc afn float -42.000000, %x
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
%r = fneg nsz float %d
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
%r = fneg nsz float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
#0:
%r = fdiv nsz float -42.000000, %x
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
%r = fneg nsz float %d
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
%r = fneg nsz float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz(float %x) {
#0:
%r = fdiv float -42.000000, %x
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
%r = fneg ninf float %d
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
%r = fneg ninf float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
#0:
%r = fdiv ninf float -42.000000, %x
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
%r = fneg ninf float %d
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
%r = fneg ninf float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf(float %x) {
#0:
%r = fdiv float -42.000000, %x
ret float %r
}
Transformation seems to be correct!
-- 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
%r = fneg nnan float %d
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
%r = fneg nnan float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
#0:
%r = fdiv nnan float -42.000000, %x
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
%r = fneg nnan float %d
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
%r = fneg nnan float %d
ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan(float %x) {
#0:
%r = fdiv nnan float -42.000000, %x
ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
#0:
%d = fdiv float -42.000000, %x
%r = fsub float -0.000000, %d
call void @use(float %d)
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 111. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
#0:
%d = fdiv float -42.000000, %x
%r = fsub float -0.000000, %d
call void @use(float %d)
ret float %r
}
=>
declare void @use(float)
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
#0:
%d = fdiv float -42.000000, %x
%r = fneg float %d
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
----------------------------------------
declare void @use(float)
define float @fdiv_op0_constant_fneg_extra_use(float %x) {
#0:
%d = fdiv float -42.000000, %x
%r = fneg float %d
call void @use(float %d)
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 115. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fdiv_op0_constant_fneg_extra_use(float %x) {
#0:
%d = fdiv float -42.000000, %x
%r = fneg float %d
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, poison }, %x
%r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d
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, poison }, %x
%r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d
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, poison }, %x
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, poison }, %x
%r = fneg <4 x double> %d
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, poison }, %x
%r = fneg <4 x double> %d
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, poison }, %x
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
%n2 = fneg <2 x double> %y
%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
%n2 = fneg <2 x double> %y
%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
ret <2 x double> %sel
}
Transformation seems to be correct!
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
call void @use(float %n1)
%n2 = fneg float %y
%sel = select i1 %cond, float %n1, float %n2
ret float %sel
}
Transformation seems to be correct! (syntactically equal)
-- 131. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
call void @use(float %n1)
%n2 = fneg float %y
%sel = select i1 %cond, float %n1, float %n2
ret float %sel
}
=>
declare void @use(float)
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
call void @use(float %n1)
%sel.v = select i1 %cond, float %x, float %y
%sel = fneg float %sel.v
ret float %sel
}
Transformation seems to be correct!
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
%n2 = fneg float %y
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
----------------------------------------
declare void @use(float)
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
%n2 = fneg float %y
call void @use(float %n2)
%sel = select i1 %cond, float %n1, float %n2
ret float %sel
}
=>
declare void @use(float)
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
#0:
%n2 = fneg float %y
call void @use(float %n2)
%sel.v = select i1 %cond, float %x, float %y
%sel = fneg float %sel.v
ret float %sel
}
Transformation seems to be correct!
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
#0:
%n1 = fsub float -0.000000, %x
call void @use(float %n1)
%n2 = fsub float -0.000000, %y
%sel = select i1 %cond, float %n1, float %n2
ret float %sel
}
Transformation seems to be correct! (syntactically equal)
-- 139. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
#0:
%n1 = fsub float -0.000000, %x
call void @use(float %n1)
%n2 = fsub float -0.000000, %y
%sel = select i1 %cond, float %n1, float %n2
ret float %sel
}
=>
declare void @use(float)
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
call void @use(float %n1)
%sel.v = select i1 %cond, float %x, float %y
%sel = fneg float %sel.v
ret float %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fneg_fneg_sel_extra_use3(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
call void @use(float %n1)
%n2 = fneg float %y
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
----------------------------------------
declare void @use(float)
define float @fneg_fneg_sel_extra_use3(float %x, float %y, i1 %cond) {
#0:
%n1 = fneg float %x
call void @use(float %n1)
%n2 = fneg float %y
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
%n2 = fneg ninf double %y
%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
%n2 = fneg ninf double %y
%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
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
%n2 = fneg ninf double %y
%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
%n2 = fneg ninf double %y
%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
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
%n2 = fneg ninf double %y
%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
%n2 = fneg ninf double %y
%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
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
%n2 = fneg ninf double %y
%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
%n2 = fneg ninf double %y
%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
ret double %sel
}
Transformation seems to be correct!
-- 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
%r = fneg float %a
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
%r = fneg float %a
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
%r = fsub float -0.000000, %a
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
%r = fsub float -0.000000, %a
ret float %r
}
=>
define float @fake_nsz_fadd_constant(float %x) {
#0:
%a = fadd float %x, 42.000000
%r = fneg float %a
ret float %r
}
Transformation seems to be correct!
-- 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
%r = fneg nsz float %a
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
%r = fneg nsz float %a
ret float %r
}
=>
define float @fneg_nsz_fadd_constant(float %x) {
#0:
%r = fsub nsz float -42.000000, %x
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
%r = fsub fast float -0.000000, %a
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
%r = fsub fast float -0.000000, %a
ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant(float %x) {
#0:
%r = fsub fast float -42.000000, %x
ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
#0:
%a = fadd float %x, 42.000000
call void @use(float %a)
%r = fneg nsz float %a
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 179. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
#0:
%a = fadd float %x, 42.000000
call void @use(float %a)
%r = fneg nsz float %a
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
#0:
%a = fadd float %x, 42.000000
call void @use(float %a)
%r = fsub fast float -0.000000, %a
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 183. InstCombinePass
----------------------------------------
declare void @use(float)
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
#0:
%a = fadd float %x, 42.000000
call void @use(float %a)
%r = fsub fast float -0.000000, %a
ret float %r
}
=>
declare void @use(float)
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
#0:
%a = fadd float %x, 42.000000
call void @use(float %a)
%r = fneg fast float %a
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 }
%r = fneg nnan nsz reassoc <2 x float> %a
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 }
%r = fneg nnan nsz reassoc <2 x float> %a
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
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, poison }
%r = fsub nsz <2 x float> { poison, -0.000000 }, %a
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, poison }
%r = fsub nsz <2 x float> { poison, -0.000000 }, %a
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, poison }, %x
ret <2 x float> %r
}
Transformation seems to be correct!
-- 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
%r = fneg nsz float %a
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
%r = fneg nsz float %a
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
%r = fsub nsz float -0.000000, %a
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
%r = fsub nsz float -0.000000, %a
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
%r = fneg nsz float %a
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
%s = select i1 %b, float %nx, float %y
%r = fneg float %s
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
%s = select i1 %b, float %nx, float %y
%r = fneg float %s
ret float %r
}
=>
define float @select_fneg_true(float %x, float %y, i1 %b) {
#0:
%y.neg = fneg float %y
%r = select i1 %b, float %x, float %y.neg
ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 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
%s = select ninf <2 x i1> %b, <2 x float> %x, <2 x float> %ny
%r = fneg nnan nsz <2 x float> %s
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
%s = select ninf <2 x i1> %b, <2 x float> %x, <2 x float> %ny
%r = fneg nnan nsz <2 x float> %s
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
%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
%s = select i1 %b, float %x, float %ny
%r = fneg nnan ninf nsz float %s
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
%s = select i1 %b, float %x, float %ny
%r = fneg nnan ninf nsz float %s
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
%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
%s = select i1 noundef %b, float %x, float %ny
%r = fneg nnan ninf nsz float %s
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
%s = select i1 noundef %b, float %x, float %ny
%r = fneg nnan ninf nsz float %s
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
%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
%s = select nsz i1 %b, float %x, float %ny
%r = fneg nnan ninf nsz float %s
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
%s = select nsz i1 %b, float %x, float %ny
%r = fneg nnan ninf nsz float %s
ret float %r
}
=>
define float @select_fneg_false_nsz(float %x, float %y, i1 %b) {
#0:
%x.neg = fneg nnan ninf nsz float %x
%r = select nnan ninf nsz i1 %b, float %x.neg, float %y
ret float %r
}
Transformation seems to be correct!
-- 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
%s = select i1 %b, float %x, float %nx
%r = fneg nnan ninf nsz float %s
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
%s = select i1 %b, float %x, float %nx
%r = fneg nnan ninf nsz float %s
ret float %r
}
=>
define float @select_common_op_fneg_true(float %x, i1 %b) {
#0:
%x.neg = fneg nnan ninf nsz float %x
%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
%s = select i1 %b, float %x, float %nx
%r = fneg nnan ninf nsz float %s
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
%s = select i1 %b, float %x, float %nx
%r = fneg nnan ninf nsz float %s
ret float %r
}
=>
define float @select_common_op_fneg_false(float %x, i1 %b) {
#0:
%x.neg = fneg nnan ninf nsz float %x
%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
%cmp = fcmp ogt float %a, %fneg
%sel = select i1 %cmp, float %fneg, float %a
%fneg1 = fneg nnan ninf nsz float %sel
ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)
-- 231. InstCombinePass
----------------------------------------
define float @fabs(float %a) {
#0:
%fneg = fneg float %a
%cmp = fcmp ogt float %a, %fneg
%sel = select i1 %cmp, float %fneg, float %a
%fneg1 = fneg nnan ninf nsz float %sel
ret float %fneg1
}
=>
define float @fabs(float %a) {
#0:
%fneg1 = fabs nnan ninf nsz float %a
ret float %fneg1
}
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
%cmp = fcmp olt float %a, %fneg
%sel = select i1 %cmp, float %fneg, float %a
%fneg1 = fneg fast float %sel
ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)
-- 235. InstCombinePass
----------------------------------------
define float @fnabs(float %a) {
#0:
%fneg = fneg float %a
%cmp = fcmp olt float %a, %fneg
%sel = select i1 %cmp, float %fneg, float %a
%fneg1 = fneg fast float %sel
ret float %fneg1
}
=>
define float @fnabs(float %a) {
#0:
%#1 = fabs fast float %a
%fneg1 = fneg fast float %#1
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
%cmp = fcmp ogt float %a, %fneg
%sel = select i1 %cmp, float %a, float %fneg
%fneg1 = fneg fast float %sel
ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)
-- 239. InstCombinePass
----------------------------------------
define float @fnabs_1(float %a) {
#0:
%fneg = fneg float %a
%cmp = fcmp ogt float %a, %fneg
%sel = select i1 %cmp, float %a, float %fneg
%fneg1 = fneg fast float %sel
ret float %fneg1
}
=>
define float @fnabs_1(float %a) {
#0:
%#1 = fabs fast float %a
%fneg1 = fneg fast float %#1
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
%cmp = fcmp olt float %a, %fneg
%sel = select nsz i1 %cmp, float %fneg, float %a
%fneg1 = fneg float %sel
ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)
-- 243. InstCombinePass
----------------------------------------
define float @fnabs_2_nsz(float %a) {
#0:
%fneg = fneg float %a
%cmp = fcmp olt float %a, %fneg
%sel = select nsz i1 %cmp, float %fneg, float %a
%fneg1 = fneg float %sel
ret float %fneg1
}
=>
define float @fnabs_2_nsz(float %a) {
#0:
%cmp = fcmp olt float %a, 0.000000
%a.neg = fneg float %a
%fneg1 = select nsz i1 %cmp, float %a, float %a.neg
ret float %fneg1
}
Transformation seems to be correct!
-- 244. PassManager<Function> : Skipping NOP
-- 245. PassManager<Function> : Skipping NOP
-- 246. InstCombinePass
----------------------------------------
define float @fnabs_2_nsz_nnan(float %a) {
#0:
%fneg = fneg float %a
%cmp = fcmp olt float %a, %fneg
%sel = select nnan nsz i1 %cmp, float %fneg, float %a
%fneg1 = fneg float %sel
ret float %fneg1
}
Transformation seems to be correct! (syntactically equal)
-- 247. InstCombinePass
----------------------------------------
define float @fnabs_2_nsz_nnan(float %a) {
#0:
%fneg = fneg float %a
%cmp = fcmp olt float %a, %fneg
%sel = select nnan nsz i1 %cmp, float %fneg, float %a
%fneg1 = fneg float %sel
ret float %fneg1
}
=>
define float @fnabs_2_nsz_nnan(float %a) {
#0:
%sel = fabs nnan nsz float %a
%fneg1 = fneg float %sel
ret float %fneg1
}
Transformation seems to be correct!
-- 248. PassManager<Function> : Skipping NOP
-- 249. PassManager<Function> : Skipping NOP
-- 250. InstCombinePass
----------------------------------------
define float @select_fneg_both(float %x, float %y, i1 %b) {
#0:
%nx = fneg float %x
%ny = fneg float %y
%s = select i1 %b, float %nx, float %ny
%r = fneg float %s
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 251. InstCombinePass
----------------------------------------
define float @select_fneg_both(float %x, float %y, i1 %b) {
#0:
%nx = fneg float %x
%ny = fneg float %y
%s = select i1 %b, float %nx, float %ny
%r = fneg float %s
ret float %r
}
=>
define float @select_fneg_both(float %x, float %y, i1 %b) {
#0:
%s.v = select i1 %b, float %x, float %y
ret float %s.v
}
Transformation seems to be correct!
-- 252. PassManager<Function> : Skipping NOP
-- 253. PassManager<Function> : Skipping NOP
-- 254. InstCombinePass
----------------------------------------
declare void @use(float)
define float @select_fneg_use1(float %x, float %y, i1 %b) {
#0:
%nx = fneg ninf float %x
call void @use(float %nx)
%s = select fast i1 %b, float %nx, float %y
%r = fneg float %s
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 255. InstCombinePass
----------------------------------------
declare void @use(float)
define float @select_fneg_use1(float %x, float %y, i1 %b) {
#0:
%nx = fneg ninf float %x
call void @use(float %nx)
%s = select fast i1 %b, float %nx, float %y
%r = fneg float %s
ret float %r
}
=>
declare void @use(float)
define float @select_fneg_use1(float %x, float %y, i1 %b) {
#0:
%nx = fneg ninf float %x
call void @use(float %nx)
%y.neg = fneg float %y
%r = select fast i1 %b, float %x, float %y.neg
ret float %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 256. PassManager<Function> : Skipping NOP
-- 257. PassManager<Function> : Skipping NOP
-- 258. InstCombinePass
----------------------------------------
declare void @use(float)
define float @select_fneg_use2(float %x, float %y, i1 %b) {
#0:
call void @use(float %y)
%nx = fneg nsz float %x
%s = select ninf i1 %b, float %nx, float %y
%r = fneg fast float %s
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 259. InstCombinePass
----------------------------------------
declare void @use(float)
define float @select_fneg_use2(float %x, float %y, i1 %b) {
#0:
call void @use(float %y)
%nx = fneg nsz float %x
%s = select ninf i1 %b, float %nx, float %y
%r = fneg fast float %s
ret float %r
}
=>
declare void @use(float)
define float @select_fneg_use2(float %x, float %y, i1 %b) {
#0:
call void @use(float %y)
%y.neg = fneg fast float %y
%r = select nnan ninf arcp contract reassoc afn i1 %b, float %x, float %y.neg
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:
- afn
- arcp
- contract
- reassoc
-- 260. PassManager<Function> : Skipping NOP
-- 261. PassManager<Function> : Skipping NOP
-- 262. InstCombinePass
----------------------------------------
declare void @use(float)
define float @select_fneg_use3(float %x, float %y, i1 %b) {
#0:
%nx = fneg float %x
%s = select i1 %b, float %nx, float %y
call void @use(float %s)
%r = fneg float %s
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 263. InstCombinePass
----------------------------------------
declare void @use(float)
define float @select_fneg_use3(float %x, float %y, i1 %b) {
#0:
%nx = fneg float %x
%s = select i1 %b, float %nx, float %y
call void @use(float %s)
%r = fneg float %s
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 264. PassManager<Function> : Skipping NOP
-- 265. PassManager<Function> : Skipping NOP
-- 266. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 267. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp(float %x, i32 %n) {
#0:
%#1 = fneg float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 268. PassManager<Function> : Skipping NOP
-- 269. PassManager<Function> : Skipping NOP
-- 270. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub float -0.000000, %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 271. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub float -0.000000, %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp(float %x, i32 %n) {
#0:
%#1 = fneg float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 272. PassManager<Function> : Skipping NOP
-- 273. PassManager<Function> : Skipping NOP
-- 274. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_nsz(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub nsz float -0.000000, %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 275. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_nsz(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub nsz float -0.000000, %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_nsz(float %x, i32 %n) {
#0:
%#1 = fneg nsz float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 276. PassManager<Function> : Skipping NOP
-- 277. PassManager<Function> : Skipping NOP
-- 278. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_p0_nsz(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub nsz float 0.000000, %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 279. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_p0_nsz(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub nsz float 0.000000, %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_p0_nsz(float %x, i32 %n) {
#0:
%#1 = fneg nsz float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 280. PassManager<Function> : Skipping NOP
-- 281. PassManager<Function> : Skipping NOP
-- 282. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_p0(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub float 0.000000, %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 283. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fsub_fneg_ldexp_p0(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fsub float 0.000000, %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 284. PassManager<Function> : Skipping NOP
-- 285. PassManager<Function> : Skipping NOP
-- 286. InstCombinePass
----------------------------------------
declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) nofree willreturn memory(none)
define <2 x float> @fneg_ldexp_vector(<2 x float> %x, <2 x i32> %n) {
#0:
%ldexp = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> %n) nofree willreturn memory(none)
%neg = fneg <2 x float> %ldexp
ret <2 x float> %neg
}
Transformation seems to be correct! (syntactically equal)
-- 287. InstCombinePass
----------------------------------------
declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) nofree willreturn memory(none)
define <2 x float> @fneg_ldexp_vector(<2 x float> %x, <2 x i32> %n) {
#0:
%ldexp = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> %n) nofree willreturn memory(none)
%neg = fneg <2 x float> %ldexp
ret <2 x float> %neg
}
=>
declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) nofree willreturn memory(none)
define <2 x float> @fneg_ldexp_vector(<2 x float> %x, <2 x i32> %n) {
#0:
%#1 = fneg <2 x float> %x
%neg = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %#1, <2 x i32> %n) nofree willreturn memory(none)
ret <2 x float> %neg
}
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:
- Unknown libcall: @llvm.ldexp.v2f32.v2i32
-- 288. PassManager<Function> : Skipping NOP
-- 289. PassManager<Function> : Skipping NOP
-- 290. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_multiuse(float %x, i32 %n, ptr %ptr) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
store float %ldexp, ptr %ptr, align 4
%neg = fneg float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 291. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_multiuse(float %x, i32 %n, ptr %ptr) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
store float %ldexp, ptr %ptr, align 4
%neg = fneg float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 292. PassManager<Function> : Skipping NOP
-- 293. PassManager<Function> : Skipping NOP
-- 294. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf_ldexp(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) NNaN nofree willreturn memory(none)
%neg = fneg float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 295. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf_ldexp(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) NNaN nofree willreturn memory(none)
%neg = fneg float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf_ldexp(float %x, i32 %n) {
#0:
%#1 = fneg nnan float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) NNaN nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 296. PassManager<Function> : Skipping NOP
-- 297. PassManager<Function> : Skipping NOP
-- 298. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf_neg(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg nnan float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 299. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf_neg(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg nnan float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf_neg(float %x, i32 %n) {
#0:
%#1 = fneg nnan float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) NNaN nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 300. PassManager<Function> : Skipping NOP
-- 301. PassManager<Function> : Skipping NOP
-- 302. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg nnan float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 303. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg nnan float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_fmf(float %x, i32 %n) {
#0:
%#1 = fneg nnan ninf float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) NNaN nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
-- 304. PassManager<Function> : Skipping NOP
-- 305. PassManager<Function> : Skipping NOP
-- 306. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract0(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 307. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract0(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract0(float %x, i32 %n) {
#0:
%#1 = fneg contract float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
- contract
-- 308. PassManager<Function> : Skipping NOP
-- 309. PassManager<Function> : Skipping NOP
-- 310. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract1(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg contract float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 311. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract1(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg contract float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract1(float %x, i32 %n) {
#0:
%#1 = fneg contract float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
- contract
-- 312. PassManager<Function> : Skipping NOP
-- 313. PassManager<Function> : Skipping NOP
-- 314. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg contract float %ldexp
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 315. InstCombinePass
----------------------------------------
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract(float %x, i32 %n) {
#0:
%ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n) nofree willreturn memory(none)
%neg = fneg contract float %ldexp
ret float %neg
}
=>
declare float @llvm.ldexp.f32.i32(float, i32) nofree willreturn memory(none)
define float @fneg_ldexp_contract(float %x, i32 %n) {
#0:
%#1 = fneg contract float %x
%neg = call float @llvm.ldexp.f32.i32(float %#1, i32 %n) nofree willreturn memory(none)
ret float %neg
}
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:
- Unknown libcall: @llvm.ldexp.f32.i32
- contract
-- 316. PassManager<Function> : Skipping NOP
-- 317. PassManager<Function> : Skipping NOP
ERROR: Unsupported metadata: 41
-- 318. InstCombinePass
ERROR: Unsupported metadata: 41
-- 319. InstCombinePass
ERROR: Unsupported metadata: 41
-- 320. PassManager<Function> : Skipping NOP
ERROR: Unsupported metadata: 41
-- 321. PassManager<Function> : Skipping NOP
-- 322. InstCombinePass
----------------------------------------
define float @test_fneg_select_constants(i1 %cond) {
#0:
%sel1 = select i1 %cond, float 0.000000, float -0.000000
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 323. InstCombinePass
----------------------------------------
define float @test_fneg_select_constants(i1 %cond) {
#0:
%sel1 = select i1 %cond, float 0.000000, float -0.000000
%neg = fneg float %sel1
ret float %neg
}
=>
define float @test_fneg_select_constants(i1 %cond) {
#0:
%neg = select i1 %cond, float -0.000000, float 0.000000
ret float %neg
}
Transformation seems to be correct!
-- 324. PassManager<Function> : Skipping NOP
-- 325. PassManager<Function> : Skipping NOP
-- 326. InstCombinePass
----------------------------------------
define <2 x float> @test_fneg_vec(<2 x i1> %cond) {
#0:
%sel1 = select <2 x i1> %cond, <2 x float> { 0.000000, -0.000000 }, <2 x float> { -0.000000, 0.000000 }
%neg = fneg <2 x float> %sel1
ret <2 x float> %neg
}
Transformation seems to be correct! (syntactically equal)
-- 327. InstCombinePass
----------------------------------------
define <2 x float> @test_fneg_vec(<2 x i1> %cond) {
#0:
%sel1 = select <2 x i1> %cond, <2 x float> { 0.000000, -0.000000 }, <2 x float> { -0.000000, 0.000000 }
%neg = fneg <2 x float> %sel1
ret <2 x float> %neg
}
=>
define <2 x float> @test_fneg_vec(<2 x i1> %cond) {
#0:
%neg = select <2 x i1> %cond, <2 x float> { -0.000000, 0.000000 }, <2 x float> { 0.000000, -0.000000 }
ret <2 x float> %neg
}
Transformation seems to be correct!
-- 328. PassManager<Function> : Skipping NOP
-- 329. PassManager<Function> : Skipping NOP
-- 330. InstCombinePass
----------------------------------------
define float @test_fneg_select_var_constant(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float %x, float -0.000000
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 331. InstCombinePass
----------------------------------------
define float @test_fneg_select_var_constant(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float %x, float -0.000000
%neg = fneg float %sel1
ret float %neg
}
=>
define float @test_fneg_select_var_constant(i1 %cond, float %x) {
#0:
%x.neg = fneg float %x
%neg = select i1 %cond, float %x.neg, float 0.000000
ret float %neg
}
Transformation seems to be correct!
-- 332. PassManager<Function> : Skipping NOP
-- 333. PassManager<Function> : Skipping NOP
-- 334. InstCombinePass
----------------------------------------
define float @test_fneg_select_var_constant_fmf1(i1 %cond, float %x) {
#0:
%sel1 = select nnan ninf nsz i1 %cond, float %x, float 1.000000
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 335. InstCombinePass
----------------------------------------
define float @test_fneg_select_var_constant_fmf1(i1 %cond, float %x) {
#0:
%sel1 = select nnan ninf nsz i1 %cond, float %x, float 1.000000
%neg = fneg float %sel1
ret float %neg
}
=>
define float @test_fneg_select_var_constant_fmf1(i1 %cond, float %x) {
#0:
%x.neg = fneg float %x
%neg = select nnan ninf nsz i1 %cond, float %x.neg, float -1.000000
ret float %neg
}
Transformation seems to be correct!
-- 336. PassManager<Function> : Skipping NOP
-- 337. PassManager<Function> : Skipping NOP
-- 338. InstCombinePass
----------------------------------------
define float @test_fneg_select_var_constant_fmf2(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float %x, float 1.000000
%neg = fneg nnan ninf nsz float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 339. InstCombinePass
----------------------------------------
define float @test_fneg_select_var_constant_fmf2(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float %x, float 1.000000
%neg = fneg nnan ninf nsz float %sel1
ret float %neg
}
=>
define float @test_fneg_select_var_constant_fmf2(i1 %cond, float %x) {
#0:
%x.neg = fneg nnan ninf nsz float %x
%neg = select nnan ninf nsz i1 %cond, float %x.neg, float -1.000000
ret float %neg
}
Transformation seems to be correct!
-- 340. PassManager<Function> : Skipping NOP
-- 341. PassManager<Function> : Skipping NOP
-- 342. InstCombinePass
----------------------------------------
define float @test_fneg_select_constant_var(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float 0.000000, float %x
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 343. InstCombinePass
----------------------------------------
define float @test_fneg_select_constant_var(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float 0.000000, float %x
%neg = fneg float %sel1
ret float %neg
}
=>
define float @test_fneg_select_constant_var(i1 %cond, float %x) {
#0:
%x.neg = fneg float %x
%neg = select i1 %cond, float -0.000000, float %x.neg
ret float %neg
}
Transformation seems to be correct!
-- 344. PassManager<Function> : Skipping NOP
-- 345. PassManager<Function> : Skipping NOP
-- 346. InstCombinePass
----------------------------------------
define float @test_fneg_select_abs(i1 %cond, float %x) {
#0:
%absx = fabs float %x
%sel1 = select i1 %cond, float 0.000000, float %absx
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 347. InstCombinePass
----------------------------------------
define float @test_fneg_select_abs(i1 %cond, float %x) {
#0:
%absx = fabs float %x
%sel1 = select i1 %cond, float 0.000000, float %absx
%neg = fneg float %sel1
ret float %neg
}
=>
define float @test_fneg_select_abs(i1 %cond, float %x) {
#0:
%absx = fabs float %x
%absx.neg = fneg float %absx
%neg = select i1 %cond, float -0.000000, float %absx.neg
ret float %neg
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 348. PassManager<Function> : Skipping NOP
-- 349. PassManager<Function> : Skipping NOP
-- 350. InstCombinePass
----------------------------------------
define float @test_fneg_fabs_select(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float 0.000000, float %x
%abs = fabs float %sel1
%neg = fneg float %abs
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 351. InstCombinePass
----------------------------------------
define float @test_fneg_fabs_select(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float 0.000000, float %x
%abs = fabs float %sel1
%neg = fneg float %abs
ret float %neg
}
=>
define float @test_fneg_fabs_select(i1 %cond, float %x) {
#0:
%#1 = fabs float %x
%.neg = fneg float %#1
%neg = select i1 %cond, float -0.000000, float %.neg
ret float %neg
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 352. PassManager<Function> : Skipping NOP
-- 353. PassManager<Function> : Skipping NOP
-- 354. InstCombinePass
----------------------------------------
declare void @use(float)
define float @test_fneg_select_constant_var_multiuse(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float 0.000000, float %x
call void @use(float %sel1)
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 355. InstCombinePass
----------------------------------------
declare void @use(float)
define float @test_fneg_select_constant_var_multiuse(i1 %cond, float %x) {
#0:
%sel1 = select i1 %cond, float 0.000000, float %x
call void @use(float %sel1)
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 356. PassManager<Function> : Skipping NOP
-- 357. PassManager<Function> : Skipping NOP
-- 358. InstCombinePass
----------------------------------------
define float @test_fneg_select_maxnum(float %x) {
#0:
%cmp1 = fcmp ogt float %x, 1.000000
%sel1 = select nnan nsz i1 %cmp1, float %x, float 1.000000
%neg = fneg float %sel1
ret float %neg
}
Transformation seems to be correct! (syntactically equal)
-- 359. InstCombinePass
----------------------------------------
define float @test_fneg_select_maxnum(float %x) {
#0:
%cmp1 = fcmp ogt float %x, 1.000000
%sel1 = select nnan nsz i1 %cmp1, float %x, float 1.000000
%neg = fneg float %sel1
ret float %neg
}
=>
define float @test_fneg_select_maxnum(float %x) {
#0:
%sel1 = fmax nnan nsz float %x, 1.000000
%neg = fneg float %sel1
ret float %neg
}
Transformation doesn't verify! (unsound)
ERROR: Target is more poisonous than source
Example:
float %x = #x7f800800 (SNaN)
Source:
i1 %cmp1 = #x0 (0)
float %sel1 = #x3f800000 (1)
float %neg = #xbf800000 (-1)
Target:
float %sel1 = poison
float %neg = poison
Source value: #xbf800000 (-1)
Target value: poison
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'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_w8alGBrn_I9Tn.bc"
------------------- SMT STATS -------------------
Num queries: 337
Num invalid: 0
Num skips: 0
Num trivial: 177 (34.4%)
Num timeout: 32 (9.5%)
Num errors: 0 (0.0%)
Num SAT: 192 (57.0%)
Num UNSAT: 113 (33.5%)
Alive2: Transform doesn't verify; aborting!
RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fneg.ll -passes=instcombine -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/fneg.ll + /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