Test source: git
Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 3. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @not_isfinite_or_zero_f16(half %x) {
#0:
%class = is.fpclass half %x, i32 615
ret i1 %class
}
Transformation seems to be correct!
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_commute_or(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpinf, %cmpzero
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 7. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_commute_or(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpinf, %cmpzero
ret i1 %class
}
=>
define i1 @not_isfinite_or_zero_f16_commute_or(half %x) {
#0:
%class = is.fpclass half %x, i32 615
ret i1 %class
}
Transformation seems to be correct!
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_negzero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x8000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 11. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_negzero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x8000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @not_isfinite_or_zero_f16_negzero(half %x) {
#0:
%class = is.fpclass half %x, i32 615
ret i1 %class
}
Transformation seems to be correct!
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_fabs_oeq_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %fabs, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 15. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_fabs_oeq_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %fabs, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @not_isfinite_or_fabs_oeq_zero_f16(half %x) {
#0:
%class = is.fpclass half %x, i32 615
ret i1 %class
}
Transformation seems to be correct!
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 19. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
=>
define <2 x i1> @not_isfinite_or_zero_v2f16(<2 x half> %x) {
#0:
%class = is.fpclass <2 x half> %x, i32 615
ret <2 x i1> %class
}
Transformation seems to be correct!
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_pos0_neg0_vec(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x8000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 23. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_pos0_neg0_vec(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x8000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
=>
define <2 x i1> @not_isfinite_or_zero_v2f16_pos0_neg0_vec(<2 x half> %x) {
#0:
%class = is.fpclass <2 x half> %x, i32 615
ret <2 x i1> %class
}
Transformation seems to be correct!
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_commute_or(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpinf, %cmpzero
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 27. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_commute_or(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpinf, %cmpzero
ret <2 x i1> %class
}
=>
define <2 x i1> @not_isfinite_or_zero_v2f16_commute_or(<2 x half> %x) {
#0:
%class = is.fpclass <2 x half> %x, i32 615
ret <2 x i1> %class
}
Transformation seems to be correct!
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_oeq_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 31. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_oeq_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @oeq_isinf_or_oeq_zero(half %x) {
#0:
%class = is.fpclass half %x, i32 612
ret i1 %class
}
Transformation seems to be correct!
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstCombinePass
----------------------------------------
define i1 @ueq_inf_or_oeq_zero(half %x) {
#0:
%cmpinf = fcmp ueq half %x, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 35. InstCombinePass
----------------------------------------
define i1 @ueq_inf_or_oeq_zero(half %x) {
#0:
%cmpinf = fcmp ueq half %x, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @ueq_inf_or_oeq_zero(half %x) {
#0:
%class = is.fpclass half %x, i32 611
ret i1 %class
}
Transformation seems to be correct!
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_fabs_oeq_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %fabs, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 39. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_fabs_oeq_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %fabs, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @oeq_isinf_or_fabs_oeq_zero(half %x) {
#0:
%class = is.fpclass half %x, i32 612
ret i1 %class
}
Transformation seems to be correct!
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstCombinePass
----------------------------------------
define i1 @ueq_0_or_oeq_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x0000
%cmpzero = fcmp oeq half %x, 0x7c00
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 43. InstCombinePass
----------------------------------------
define i1 @ueq_0_or_oeq_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x0000
%cmpzero = fcmp oeq half %x, 0x7c00
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @ueq_0_or_oeq_inf(half %x) {
#0:
%class = is.fpclass half %x, i32 611
ret i1 %class
}
Transformation seems to be correct!
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_not_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c01
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 47. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_not_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c01
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @not_isfinite_or_zero_f16_not_inf(half %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InstCombinePass
----------------------------------------
define i1 @ueq_inf_or_ueq_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp ueq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 51. InstCombinePass
----------------------------------------
define i1 @ueq_inf_or_ueq_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp ueq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @ueq_inf_or_ueq_zero(half %x) {
#0:
%class = is.fpclass half %x, i32 615
ret i1 %class
}
Transformation seems to be correct!
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass
----------------------------------------
define i1 @not_isfinite_and_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = and i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 55. InstCombinePass
----------------------------------------
define i1 @not_isfinite_and_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = and i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @not_isfinite_and_zero_f16(half %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_multi_use_cmp0(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
store i1 %cmpinf, ptr %ptr, align 1
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 59. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_multi_use_cmp0(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
store i1 %cmpinf, ptr %ptr, align 1
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_multi_use_cmp1(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
store i1 %cmpzero, ptr %ptr, align 1
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 63. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_multi_use_cmp1(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
store i1 %cmpzero, ptr %ptr, align 1
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_neg_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0xfc00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 67. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_neg_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0xfc00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @not_isfinite_or_zero_f16_neg_inf(half %x) {
#0:
%class = fcmp ueq half %x, 0x0000
ret i1 %class
}
Transformation seems to be correct!
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstCombinePass
----------------------------------------
define i1 @olt_0_or_fabs_ueq_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp olt half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 71. InstCombinePass
----------------------------------------
define i1 @olt_0_or_fabs_ueq_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp olt half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @olt_0_or_fabs_ueq_inf(half %x) {
#0:
%class = is.fpclass half %x, i32 543
ret i1 %class
}
Transformation seems to be correct!
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstCombinePass
----------------------------------------
define i1 @oeq_0_or_fabs_ult_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ult half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 75. InstCombinePass
----------------------------------------
define i1 @oeq_0_or_fabs_ult_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ult half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
=>
define i1 @oeq_0_or_fabs_ult_inf(half %x) {
#0:
%#1 = fabs half %x
%class = fcmp une half %#1, 0x7c00
ret i1 %class
}
Transformation seems to be correct!
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_multi_not_0(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x3c00
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 79. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_multi_not_0(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x3c00
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_fabs_wrong_val(half %x, half %y) {
#0:
%fabs = fabs half %y
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 83. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_fabs_wrong_val(half %x, half %y) {
#0:
%fabs = fabs half %y
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_not_fabs(half %x) {
#0:
%fabs = canonicalize half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 87. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_not_fabs(half %x) {
#0:
%fabs = canonicalize half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 91. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
=>
define i1 @negated_isfinite_or_zero_f16(half %x) {
#0:
%not.class = is.fpclass half %x, i32 408
ret i1 %not.class
}
Transformation seems to be correct!
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_commute_and(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpinf, %cmpzero
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 95. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_commute_and(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpinf, %cmpzero
ret i1 %not.class
}
=>
define i1 @negated_isfinite_or_zero_f16_commute_and(half %x) {
#0:
%not.class = is.fpclass half %x, i32 408
ret i1 %not.class
}
Transformation seems to be correct!
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_negzero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x8000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 99. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_negzero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x8000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
=>
define i1 @negated_isfinite_or_zero_f16_negzero(half %x) {
#0:
%not.class = is.fpclass half %x, i32 408
ret i1 %not.class
}
Transformation seems to be correct!
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. InstCombinePass
----------------------------------------
define <2 x i1> @negated_isfinite_or_zero_v2f16(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp one <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp une <2 x half> %x, { 0x0000, 0x0000 }
%not.class = and <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 103. InstCombinePass
----------------------------------------
define <2 x i1> @negated_isfinite_or_zero_v2f16(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp one <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp une <2 x half> %x, { 0x0000, 0x0000 }
%not.class = and <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %not.class
}
=>
define <2 x i1> @negated_isfinite_or_zero_v2f16(<2 x half> %x) {
#0:
%not.class = is.fpclass <2 x half> %x, i32 408
ret <2 x i1> %not.class
}
Transformation seems to be correct!
-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstCombinePass
----------------------------------------
define <2 x i1> @negated_isfinite_or_zero_v2f16_comumte(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp one <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp une <2 x half> %x, { 0x0000, 0x0000 }
%not.class = and <2 x i1> %cmpinf, %cmpzero
ret <2 x i1> %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 107. InstCombinePass
----------------------------------------
define <2 x i1> @negated_isfinite_or_zero_v2f16_comumte(<2 x half> %x) {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp one <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp une <2 x half> %x, { 0x0000, 0x0000 }
%not.class = and <2 x i1> %cmpinf, %cmpzero
ret <2 x i1> %not.class
}
=>
define <2 x i1> @negated_isfinite_or_zero_v2f16_comumte(<2 x half> %x) {
#0:
%not.class = is.fpclass <2 x half> %x, i32 408
ret <2 x i1> %not.class
}
Transformation seems to be correct!
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_not_une_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp one half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 111. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_not_une_zero(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp one half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
=>
define i1 @negated_isfinite_or_zero_f16_not_une_zero(half %x) {
#0:
%not.class = is.fpclass half %x, i32 408
ret i1 %not.class
}
Transformation seems to be correct!
-- 112. PassManager<Function> : Skipping NOP
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_and_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = or i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 115. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_and_zero_f16(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = or i1 %cmpzero, %cmpinf
ret i1 %not.class
}
=>
define i1 @negated_isfinite_and_zero_f16(half %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_swapped_constants(half %x) {
#0:
%fabs = fabs half %x
%cmpzero = fcmp one half %fabs, 0x0000
%cmpinf = fcmp une half %x, 0x7c00
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 119. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_swapped_constants(half %x) {
#0:
%fabs = fabs half %x
%cmpzero = fcmp one half %fabs, 0x0000
%cmpinf = fcmp une half %x, 0x7c00
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
=>
define i1 @negated_isfinite_or_zero_f16_swapped_constants(half %x) {
#0:
%not.class = is.fpclass half %x, i32 412
ret i1 %not.class
}
Transformation seems to be correct!
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp0(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
store i1 %cmpinf, ptr %ptr, align 1
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 123. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp0(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
store i1 %cmpinf, ptr %ptr, align 1
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp1(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
store i1 %cmpzero, ptr %ptr, align 1
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 127. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp1(half %x, ptr %ptr) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
store i1 %cmpzero, ptr %ptr, align 1
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp0_not_one_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp une half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 131. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp0_not_one_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp une half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
=>
define i1 @negated_isfinite_or_zero_f16_multi_use_cmp0_not_one_inf(half %x) {
#0:
%not.class = is.fpclass half %x, i32 411
ret i1 %not.class
}
Transformation seems to be correct!
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_fabs_wrong_value(half %x, half %y) {
#0:
%fabs = fabs half %y
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 135. InstCombinePass
----------------------------------------
define i1 @negated_isfinite_or_zero_f16_fabs_wrong_value(half %x, half %y) {
#0:
%fabs = fabs half %y
%cmpinf = fcmp one half %fabs, 0x7c00
%cmpzero = fcmp une half %x, 0x0000
%not.class = and i1 %cmpzero, %cmpinf
ret i1 %not.class
}
Transformation seems to be correct! (syntactically equal)
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass
----------------------------------------
define i1 @fcmp_une_0_or_fcmp_une_inf(half %x) {
#0:
%cmpzero = fcmp une half %x, 0x0000
%cmpinf = fcmp une half %x, 0x7c00
%or = or i1 %cmpzero, %cmpinf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 139. InstCombinePass
----------------------------------------
define i1 @fcmp_une_0_or_fcmp_une_inf(half %x) {
#0:
%cmpzero = fcmp une half %x, 0x0000
%cmpinf = fcmp une half %x, 0x7c00
%or = or i1 %cmpzero, %cmpinf
ret i1 %or
}
=>
define i1 @fcmp_une_0_or_fcmp_une_inf(half %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass
----------------------------------------
define i1 @fcmp_one_0_and_fcmp_une_fabs_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpzero = fcmp one half %x, 0x0000
%cmpinf = fcmp une half %fabs, 0x7c00
%and = and i1 %cmpzero, %cmpinf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 143. InstCombinePass
----------------------------------------
define i1 @fcmp_one_0_and_fcmp_une_fabs_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpzero = fcmp one half %x, 0x0000
%cmpinf = fcmp une half %fabs, 0x7c00
%and = and i1 %cmpzero, %cmpinf
ret i1 %and
}
=>
define i1 @fcmp_one_0_and_fcmp_une_fabs_inf(half %x) {
#0:
%and = is.fpclass half %x, i32 408
ret i1 %and
}
Transformation seems to be correct!
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstCombinePass
----------------------------------------
define i1 @fcmp_une_0_and_fcmp_une_fabs_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpzero = fcmp une half %x, 0x0000
%cmpinf = fcmp une half %fabs, 0x7c00
%and = and i1 %cmpzero, %cmpinf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 147. InstCombinePass
----------------------------------------
define i1 @fcmp_une_0_and_fcmp_une_fabs_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpzero = fcmp une half %x, 0x0000
%cmpinf = fcmp une half %fabs, 0x7c00
%and = and i1 %cmpzero, %cmpinf
ret i1 %and
}
=>
define i1 @fcmp_une_0_and_fcmp_une_fabs_inf(half %x) {
#0:
%and = is.fpclass half %x, i32 411
ret i1 %and
}
Transformation seems to be correct!
-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstCombinePass
----------------------------------------
define i1 @fcmp_une_0_and_fcmp_une_neginf(half %x) {
#0:
%cmpzero = fcmp une half %x, 0x0000
%cmpinf = fcmp une half %x, 0xfc00
%or = or i1 %cmpzero, %cmpinf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 151. InstCombinePass
----------------------------------------
define i1 @fcmp_une_0_and_fcmp_une_neginf(half %x) {
#0:
%cmpzero = fcmp une half %x, 0x0000
%cmpinf = fcmp une half %x, 0xfc00
%or = or i1 %cmpzero, %cmpinf
ret i1 %or
}
=>
define i1 @fcmp_une_0_and_fcmp_une_neginf(half %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 155. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
=>
define i1 @issubnormal_or_inf(half %x) {
#0:
%class = is.fpclass half %x, i32 756
ret i1 %class
}
Transformation seems to be correct!
-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 159. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
=>
define i1 @olt_smallest_normal_or_inf(half %x) {
#0:
%class = is.fpclass half %x, i32 764
ret i1 %class
}
Transformation seems to be correct!
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
-- 162. InstCombinePass
----------------------------------------
define i1 @not_issubnormal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp une half %fabs, 0x7c00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%not = and i1 %cmp.smallest.normal, %cmpinf
ret i1 %not
}
Transformation seems to be correct! (syntactically equal)
-- 163. InstCombinePass
----------------------------------------
define i1 @not_issubnormal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp une half %fabs, 0x7c00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%not = and i1 %cmp.smallest.normal, %cmpinf
ret i1 %not
}
=>
define i1 @not_issubnormal_or_inf(half %x) {
#0:
%not = is.fpclass half %x, i32 267
ret i1 %not
}
Transformation seems to be correct!
-- 164. PassManager<Function> : Skipping NOP
-- 165. PassManager<Function> : Skipping NOP
-- 166. InstCombinePass
----------------------------------------
define i1 @issubnormal_uge_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 167. InstCombinePass
----------------------------------------
define i1 @issubnormal_uge_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
=>
define i1 @issubnormal_uge_or_inf(half %x) {
#0:
%class = is.fpclass half %x, i32 783
ret i1 %class
}
Transformation seems to be correct!
-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_inf_wrong_val(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0401
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 171. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_inf_wrong_val(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0401
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Function> : Skipping NOP
-- 174. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_inf_neg_smallest_normal(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x8400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 175. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_inf_neg_smallest_normal(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x8400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
=>
define i1 @issubnormal_or_inf_neg_smallest_normal(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
ret i1 %cmpinf
}
Transformation seems to be correct!
-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstCombinePass
----------------------------------------
define i1 @fneg_fabs_olt_neg_smallest_normal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%fneg.fabs = fneg half %fabs
%cmp.smallest.normal = fcmp olt half %fneg.fabs, 0x8400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 179. InstCombinePass
----------------------------------------
define i1 @fneg_fabs_olt_neg_smallest_normal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%fneg.fabs = fneg half %fabs
%cmp.smallest.normal = fcmp olt half %fneg.fabs, 0x8400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
=>
define i1 @fneg_fabs_olt_neg_smallest_normal_or_inf(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%cmp.smallest.normal = fcmp ogt half %fabs, 0x0400
%class = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %class
}
Transformation seems to be correct!
-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_finite_olt(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp olt half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 183. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_finite_olt(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp olt half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %or
}
=>
define i1 @issubnormal_or_finite_olt(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp one half %fabs, 0x7c00
ret i1 %cmpinf
}
Transformation seems to be correct!
-- 184. PassManager<Function> : Skipping NOP
-- 185. PassManager<Function> : Skipping NOP
-- 186. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_finite_uge(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp uge half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 187. InstCombinePass
----------------------------------------
define i1 @issubnormal_or_finite_uge(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp uge half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %or
}
=>
define i1 @issubnormal_or_finite_uge(half %x) {
#0:
%or = is.fpclass half %x, i32 759
ret i1 %or
}
Transformation seems to be correct!
-- 188. PassManager<Function> : Skipping NOP
-- 189. PassManager<Function> : Skipping NOP
-- 190. InstCombinePass
----------------------------------------
define i1 @issubnormal_and_finite_olt(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp olt half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%and = and i1 %cmp.smallest.normal, %cmpinf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 191. InstCombinePass
----------------------------------------
define i1 @issubnormal_and_finite_olt(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp olt half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%and = and i1 %cmp.smallest.normal, %cmpinf
ret i1 %and
}
=>
define i1 @issubnormal_and_finite_olt(half %x) {
#0:
%and = is.fpclass half %x, i32 240
ret i1 %and
}
Transformation seems to be correct!
-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InstCombinePass
----------------------------------------
define i1 @not_zero_and_subnormal(half %x) {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %fabs, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 195. InstCombinePass
----------------------------------------
define i1 @not_zero_and_subnormal(half %x) {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %fabs, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
=>
define i1 @not_zero_and_subnormal(half %x) {
#0:
%or = fcmp ord half %x, 0x0000
ret i1 %or
}
Transformation seems to be correct!
-- 196. PassManager<Function> : Skipping NOP
-- 197. PassManager<Function> : Skipping NOP
-- 198. InstCombinePass
----------------------------------------
define i1 @fcmp_fabs_uge_inf_or_fabs_uge_smallest_norm(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp uge half %fabs, 0x7c00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 199. InstCombinePass
----------------------------------------
define i1 @fcmp_fabs_uge_inf_or_fabs_uge_smallest_norm(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp uge half %fabs, 0x7c00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmpinf
ret i1 %or
}
=>
define i1 @fcmp_fabs_uge_inf_or_fabs_uge_smallest_norm(half %x) {
#0:
%or = is.fpclass half %x, i32 783
ret i1 %or
}
Transformation seems to be correct!
-- 200. PassManager<Function> : Skipping NOP
-- 201. PassManager<Function> : Skipping NOP
-- 202. InstCombinePass
----------------------------------------
define i1 @is_finite_and_ord(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%ord = fcmp ord half %x, %x
%and = and i1 %ord, %is.finite
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 203. InstCombinePass
----------------------------------------
define i1 @is_finite_and_ord(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%ord = fcmp ord half %x, %x
%and = and i1 %ord, %is.finite
ret i1 %and
}
=>
define i1 @is_finite_and_ord(half %x) {
#0:
%fabs = fabs half %x
%and = fcmp oeq half %fabs, 0x7c00
ret i1 %and
}
Transformation seems to be correct!
-- 204. PassManager<Function> : Skipping NOP
-- 205. PassManager<Function> : Skipping NOP
-- 206. InstCombinePass
----------------------------------------
define i1 @is_finite_and_uno(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%uno = fcmp uno half %x, %x
%and = and i1 %uno, %is.finite
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 207. InstCombinePass
----------------------------------------
define i1 @is_finite_and_uno(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%uno = fcmp uno half %x, %x
%and = and i1 %uno, %is.finite
ret i1 %and
}
=>
define i1 @is_finite_and_uno(half %x) {
#0:
%and = fcmp uno half %x, 0x0000
ret i1 %and
}
Transformation seems to be correct!
-- 208. PassManager<Function> : Skipping NOP
-- 209. PassManager<Function> : Skipping NOP
-- 210. InstCombinePass
----------------------------------------
define i1 @is_finite_or_ord(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%ord = fcmp ord half %x, %x
%or = or i1 %ord, %is.finite
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 211. InstCombinePass
----------------------------------------
define i1 @is_finite_or_ord(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%ord = fcmp ord half %x, %x
%or = or i1 %ord, %is.finite
ret i1 %or
}
=>
define i1 @is_finite_or_ord(half %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 212. PassManager<Function> : Skipping NOP
-- 213. PassManager<Function> : Skipping NOP
-- 214. InstCombinePass
----------------------------------------
define i1 @is_finite_or_uno(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%uno = fcmp uno half %x, %x
%or = or i1 %uno, %is.finite
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 215. InstCombinePass
----------------------------------------
define i1 @is_finite_or_uno(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
%uno = fcmp uno half %x, %x
%or = or i1 %uno, %is.finite
ret i1 %or
}
=>
define i1 @is_finite_or_uno(half %x) {
#0:
%fabs = fabs half %x
%is.finite = fcmp ueq half %fabs, 0x7c00
ret i1 %is.finite
}
Transformation seems to be correct!
-- 216. PassManager<Function> : Skipping NOP
-- 217. PassManager<Function> : Skipping NOP
-- 218. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_uno(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%class = or i1 %cmpinf, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 219. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_uno(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%class = or i1 %cmpinf, %uno
ret i1 %class
}
=>
define i1 @oeq_isinf_or_uno(half %x) {
#0:
%#1 = fabs half %x
%class = fcmp ueq half %#1, 0x7c00
ret i1 %class
}
Transformation seems to be correct!
-- 220. PassManager<Function> : Skipping NOP
-- 221. PassManager<Function> : Skipping NOP
-- 222. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_ord(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp ord half %x, 0x0000
%class = or i1 %cmpinf, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 223. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_or_ord(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp ord half %x, 0x0000
%class = or i1 %cmpinf, %uno
ret i1 %class
}
=>
define i1 @oeq_isinf_or_ord(half %x) {
#0:
%class = fcmp ord half %x, 0x0000
ret i1 %class
}
Transformation seems to be correct!
-- 224. PassManager<Function> : Skipping NOP
-- 225. PassManager<Function> : Skipping NOP
-- 226. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_and_uno(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%and = and i1 %cmpinf, %uno
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 227. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_and_uno(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%and = and i1 %cmpinf, %uno
ret i1 %and
}
=>
define i1 @oeq_isinf_and_uno(half %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 228. PassManager<Function> : Skipping NOP
-- 229. PassManager<Function> : Skipping NOP
-- 230. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_and_ord(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp ord half %x, 0x0000
%and = and i1 %cmpinf, %uno
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 231. InstCombinePass
----------------------------------------
define i1 @oeq_isinf_and_ord(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
%uno = fcmp ord half %x, 0x0000
%and = and i1 %cmpinf, %uno
ret i1 %and
}
=>
define i1 @oeq_isinf_and_ord(half %x) {
#0:
%fabs = fabs half %x
%cmpinf = fcmp oeq half %fabs, 0x7c00
ret i1 %cmpinf
}
Transformation seems to be correct!
-- 232. PassManager<Function> : Skipping NOP
-- 233. PassManager<Function> : Skipping NOP
-- 234. InstCombinePass
----------------------------------------
define i1 @isnormal_or_zero(half %x) nofree willreturn memory(none) {
entry:
%iseq = fcmp ord half %x, 0x0000
%fabs = fabs half %x
%isinf = fcmp ult half %fabs, 0x7c00
%isnormal = fcmp uge half %fabs, 0x0400
%and = and i1 %iseq, %isinf
%and1 = and i1 %isnormal, %and
%cmp = fcmp oeq half %x, 0x0000
%spec.select = or i1 %cmp, %and1
ret i1 %spec.select
}
Transformation seems to be correct! (syntactically equal)
-- 235. InstCombinePass
----------------------------------------
define i1 @isnormal_or_zero(half %x) nofree willreturn memory(none) {
entry:
%iseq = fcmp ord half %x, 0x0000
%fabs = fabs half %x
%isinf = fcmp ult half %fabs, 0x7c00
%isnormal = fcmp uge half %fabs, 0x0400
%and = and i1 %iseq, %isinf
%and1 = and i1 %isnormal, %and
%cmp = fcmp oeq half %x, 0x0000
%spec.select = or i1 %cmp, %and1
ret i1 %spec.select
}
=>
define i1 @isnormal_or_zero(half %x) nofree willreturn memory(none) {
entry:
%and1 = is.fpclass half %x, i32 360
ret i1 %and1
}
Transformation seems to be correct!
-- 236. PassManager<Function> : Skipping NOP
-- 237. PassManager<Function> : Skipping NOP
-- 238. InstCombinePass
----------------------------------------
define i1 @isnormal_uge_or_zero_oeq(half %x) nofree willreturn memory(none) {
entry:
%fabs = fabs half %x
%is.normal = fcmp uge half %fabs, 0x0400
%is.zero = fcmp oeq half %x, 0x0000
%or = or i1 %is.normal, %is.zero
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 239. InstCombinePass
----------------------------------------
define i1 @isnormal_uge_or_zero_oeq(half %x) nofree willreturn memory(none) {
entry:
%fabs = fabs half %x
%is.normal = fcmp uge half %fabs, 0x0400
%is.zero = fcmp oeq half %x, 0x0000
%or = or i1 %is.normal, %is.zero
ret i1 %or
}
=>
define i1 @isnormal_uge_or_zero_oeq(half %x) nofree willreturn memory(none) {
entry:
%or = is.fpclass half %x, i32 879
ret i1 %or
}
Transformation seems to be correct!
-- 240. PassManager<Function> : Skipping NOP
-- 241. PassManager<Function> : Skipping NOP
-- 242. InstCombinePass
----------------------------------------
define i1 @isnormalinf_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%or = or i1 %is.normal.inf, %is.ord
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 243. InstCombinePass
----------------------------------------
define i1 @isnormalinf_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%or = or i1 %is.normal.inf, %is.ord
ret i1 %or
}
=>
define i1 @isnormalinf_or_ord(half %x) nofree willreturn memory(none) {
#0:
%or = fcmp ord half %x, 0x0000
ret i1 %or
}
Transformation seems to be correct!
-- 244. PassManager<Function> : Skipping NOP
-- 245. PassManager<Function> : Skipping NOP
-- 246. InstCombinePass
----------------------------------------
define i1 @ord_or_isnormalinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%or = or i1 %is.ord, %is.normal.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 247. InstCombinePass
----------------------------------------
define i1 @ord_or_isnormalinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%or = or i1 %is.ord, %is.normal.inf
ret i1 %or
}
=>
define i1 @ord_or_isnormalinf(half %x) nofree willreturn memory(none) {
#0:
%or = fcmp ord half %x, 0x0000
ret i1 %or
}
Transformation seems to be correct!
-- 248. PassManager<Function> : Skipping NOP
-- 249. PassManager<Function> : Skipping NOP
-- 250. InstCombinePass
----------------------------------------
define i1 @une_or_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%is.normal.inf = fcmp oge half %x, 0x0400
%is.une = fcmp une half %x, 0x0000
%or = or i1 %is.une, %is.normal.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 251. InstCombinePass
----------------------------------------
define i1 @une_or_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%is.normal.inf = fcmp oge half %x, 0x0400
%is.une = fcmp une half %x, 0x0000
%or = or i1 %is.une, %is.normal.inf
ret i1 %or
}
=>
define i1 @une_or_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%is.une = fcmp une half %x, 0x0000
ret i1 %is.une
}
Transformation seems to be correct!
-- 252. PassManager<Function> : Skipping NOP
-- 253. PassManager<Function> : Skipping NOP
-- 254. InstCombinePass
----------------------------------------
define i1 @isnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%or = or i1 %is.normal.inf, %is.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 255. InstCombinePass
----------------------------------------
define i1 @isnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%or = or i1 %is.normal.inf, %is.inf
ret i1 %or
}
=>
define i1 @isnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%or = is.fpclass half %x, i32 780
ret i1 %or
}
Transformation seems to be correct!
-- 256. PassManager<Function> : Skipping NOP
-- 257. PassManager<Function> : Skipping NOP
-- 258. InstCombinePass
----------------------------------------
define i1 @posisnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.pos.normal.inf = fcmp oge half %x, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%or = or i1 %is.pos.normal.inf, %is.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 259. InstCombinePass
----------------------------------------
define i1 @posisnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.pos.normal.inf = fcmp oge half %x, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%or = or i1 %is.pos.normal.inf, %is.inf
ret i1 %or
}
=>
define i1 @posisnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%or = is.fpclass half %x, i32 772
ret i1 %or
}
Transformation seems to be correct!
-- 260. PassManager<Function> : Skipping NOP
-- 261. PassManager<Function> : Skipping NOP
-- 262. InstCombinePass
----------------------------------------
define i1 @isnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.pos.inf = fcmp oeq half %x, 0x7c00
%or = or i1 %is.normal.inf, %is.pos.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 263. InstCombinePass
----------------------------------------
define i1 @isnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.pos.inf = fcmp oeq half %x, 0x7c00
%or = or i1 %is.normal.inf, %is.pos.inf
ret i1 %or
}
=>
define i1 @isnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%or = is.fpclass half %x, i32 780
ret i1 %or
}
Transformation seems to be correct!
-- 264. PassManager<Function> : Skipping NOP
-- 265. PassManager<Function> : Skipping NOP
-- 266. InstCombinePass
----------------------------------------
define i1 @isnormalinf_and_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%and = and i1 %is.normal.inf, %is.inf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 267. InstCombinePass
----------------------------------------
define i1 @isnormalinf_and_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%and = and i1 %is.normal.inf, %is.inf
ret i1 %and
}
=>
define i1 @isnormalinf_and_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.inf = fcmp oeq half %fabs, 0x7c00
ret i1 %is.inf
}
Transformation seems to be correct!
-- 268. PassManager<Function> : Skipping NOP
-- 269. PassManager<Function> : Skipping NOP
-- 270. InstCombinePass
----------------------------------------
define i1 @posisnormalinf_and_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.pos.normal.inf = fcmp oge half %x, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%and = and i1 %is.pos.normal.inf, %is.inf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 271. InstCombinePass
----------------------------------------
define i1 @posisnormalinf_and_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.pos.normal.inf = fcmp oge half %x, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%and = and i1 %is.pos.normal.inf, %is.inf
ret i1 %and
}
=>
define i1 @posisnormalinf_and_posinf(half %x) nofree willreturn memory(none) {
#0:
%and = fcmp oeq half %x, 0x7c00
ret i1 %and
}
Transformation seems to be correct!
-- 272. PassManager<Function> : Skipping NOP
-- 273. PassManager<Function> : Skipping NOP
-- 274. InstCombinePass
----------------------------------------
define i1 @isnormalinf_and_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.pos.inf = fcmp oeq half %x, 0x7c00
%and = and i1 %is.normal.inf, %is.pos.inf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 275. InstCombinePass
----------------------------------------
define i1 @isnormalinf_and_posinf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%is.pos.inf = fcmp oeq half %x, 0x7c00
%and = and i1 %is.normal.inf, %is.pos.inf
ret i1 %and
}
=>
define i1 @isnormalinf_and_posinf(half %x) nofree willreturn memory(none) {
#0:
%and = fcmp oeq half %x, 0x7c00
ret i1 %and
}
Transformation seems to be correct!
-- 276. PassManager<Function> : Skipping NOP
-- 277. PassManager<Function> : Skipping NOP
-- 278. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%or = or i1 %not.is.normal.inf, %is.ord
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 279. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%or = or i1 %not.is.normal.inf, %is.ord
ret i1 %or
}
=>
define i1 @not_isnormalinf_or_ord(half %x) nofree willreturn memory(none) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 280. PassManager<Function> : Skipping NOP
-- 281. PassManager<Function> : Skipping NOP
-- 282. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%and = and i1 %not.is.normal.inf, %is.ord
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 283. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.ord = fcmp ord half %x, 0x0000
%and = and i1 %not.is.normal.inf, %is.ord
ret i1 %and
}
=>
define i1 @not_isnormalinf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%and = is.fpclass half %x, i32 240
ret i1 %and
}
Transformation seems to be correct!
-- 284. PassManager<Function> : Skipping NOP
-- 285. PassManager<Function> : Skipping NOP
-- 286. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.inf = fcmp olt half %fabs, 0x7c00
%or = or i1 %not.is.normal.inf, %is.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 287. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.inf = fcmp olt half %fabs, 0x7c00
%or = or i1 %not.is.normal.inf, %is.inf
ret i1 %or
}
=>
define i1 @not_isnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%#1 = fabs half %x
%or = fcmp une half %#1, 0x7c00
ret i1 %or
}
Transformation seems to be correct!
-- 288. PassManager<Function> : Skipping NOP
-- 289. PassManager<Function> : Skipping NOP
-- 290. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.uno = fcmp uno half %fabs, 0x0000
%or = or i1 %not.is.normal.inf, %is.uno
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 291. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.uno = fcmp uno half %fabs, 0x0000
%or = or i1 %not.is.normal.inf, %is.uno
ret i1 %or
}
=>
define i1 @not_isnormalinf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
ret i1 %not.is.normal.inf
}
Transformation seems to be correct!
-- 292. PassManager<Function> : Skipping NOP
-- 293. PassManager<Function> : Skipping NOP
-- 294. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_uno_nofabs(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.uno = fcmp uno half %x, 0x0000
%or = or i1 %not.is.normal.inf, %is.uno
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 295. InstCombinePass
----------------------------------------
define i1 @not_isnormalinf_or_uno_nofabs(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
%is.uno = fcmp uno half %x, 0x0000
%or = or i1 %not.is.normal.inf, %is.uno
ret i1 %or
}
=>
define i1 @not_isnormalinf_or_uno_nofabs(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.normal.inf = fcmp ult half %fabs, 0x0400
ret i1 %not.is.normal.inf
}
Transformation seems to be correct!
-- 296. PassManager<Function> : Skipping NOP
-- 297. PassManager<Function> : Skipping NOP
-- 298. InstCombinePass
----------------------------------------
define i1 @not_negisnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.neg.normal.inf = fcmp ult half %x, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%or = or i1 %not.is.neg.normal.inf, %is.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 299. InstCombinePass
----------------------------------------
define i1 @not_negisnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%not.is.neg.normal.inf = fcmp ult half %x, 0x0400
%is.inf = fcmp oeq half %fabs, 0x7c00
%or = or i1 %not.is.neg.normal.inf, %is.inf
ret i1 %or
}
=>
define i1 @not_negisnormalinf_or_inf(half %x) nofree willreturn memory(none) {
#0:
%or = is.fpclass half %x, i32 767
ret i1 %or
}
Transformation seems to be correct!
-- 300. PassManager<Function> : Skipping NOP
-- 301. PassManager<Function> : Skipping NOP
-- 302. InstCombinePass
----------------------------------------
define i1 @not_negisnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%not.is.pos.normal.inf = fcmp ult half %x, 0x0400
%is.inf = fcmp oeq half %x, 0x7c00
%or = or i1 %not.is.pos.normal.inf, %is.inf
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 303. InstCombinePass
----------------------------------------
define i1 @not_negisnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%not.is.pos.normal.inf = fcmp ult half %x, 0x0400
%is.inf = fcmp oeq half %x, 0x7c00
%or = or i1 %not.is.pos.normal.inf, %is.inf
ret i1 %or
}
=>
define i1 @not_negisnormalinf_or_posinf(half %x) nofree willreturn memory(none) {
#0:
%or = is.fpclass half %x, i32 767
ret i1 %or
}
Transformation seems to be correct!
-- 304. PassManager<Function> : Skipping NOP
-- 305. PassManager<Function> : Skipping NOP
-- 306. InstCombinePass
----------------------------------------
define i1 @not_isposnormalinf_and_isnormalinf(half %x) nofree willreturn memory(none) {
#0:
%not.is.pos.normal.inf = fcmp ult half %x, 0x0400
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%and = and i1 %not.is.pos.normal.inf, %is.normal.inf
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 307. InstCombinePass
----------------------------------------
define i1 @not_isposnormalinf_and_isnormalinf(half %x) nofree willreturn memory(none) {
#0:
%not.is.pos.normal.inf = fcmp ult half %x, 0x0400
%fabs = fabs half %x
%is.normal.inf = fcmp oge half %fabs, 0x0400
%and = and i1 %not.is.pos.normal.inf, %is.normal.inf
ret i1 %and
}
=>
define i1 @not_isposnormalinf_and_isnormalinf(half %x) nofree willreturn memory(none) {
#0:
%and = is.fpclass half %x, i32 12
ret i1 %and
}
Transformation seems to be correct!
-- 308. PassManager<Function> : Skipping NOP
-- 309. PassManager<Function> : Skipping NOP
-- 310. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 311. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %ord
ret i1 %class
}
=>
define i1 @olt_smallest_normal_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
ret i1 %ord
}
Transformation seems to be correct!
-- 312. PassManager<Function> : Skipping NOP
-- 313. PassManager<Function> : Skipping NOP
-- 314. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 315. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %uno
ret i1 %class
}
=>
define i1 @olt_smallest_normal_or_uno(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 255
ret i1 %class
}
Transformation seems to be correct!
-- 316. PassManager<Function> : Skipping NOP
-- 317. PassManager<Function> : Skipping NOP
-- 318. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_finite(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.finite = fcmp olt half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %is.finite
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 319. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_finite(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.finite = fcmp olt half %fabs, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %is.finite
ret i1 %class
}
=>
define i1 @olt_smallest_normal_or_finite(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp one half %x, 0x7c00
ret i1 %class
}
Transformation seems to be correct!
-- 320. PassManager<Function> : Skipping NOP
-- 321. PassManager<Function> : Skipping NOP
-- 322. InstCombinePass
----------------------------------------
define i1 @uge_smallest_normal_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 323. InstCombinePass
----------------------------------------
define i1 @uge_smallest_normal_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %ord
ret i1 %class
}
=>
define i1 @uge_smallest_normal_or_ord(half %x) nofree willreturn memory(none) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 324. PassManager<Function> : Skipping NOP
-- 325. PassManager<Function> : Skipping NOP
-- 326. InstCombinePass
----------------------------------------
define i1 @uge_smallest_normal_or_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 327. InstCombinePass
----------------------------------------
define i1 @uge_smallest_normal_or_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %uno
ret i1 %class
}
=>
define i1 @uge_smallest_normal_or_uno(half %x) nofree willreturn memory(none) {
#0:
%cmp.smallest.normal = fcmp uge half %x, 0x0400
ret i1 %cmp.smallest.normal
}
Transformation seems to be correct!
-- 328. PassManager<Function> : Skipping NOP
-- 329. PassManager<Function> : Skipping NOP
-- 330. InstCombinePass
----------------------------------------
define i1 @uge_smallest_normal_and_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %cmp.smallest.normal, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 331. InstCombinePass
----------------------------------------
define i1 @uge_smallest_normal_and_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %cmp.smallest.normal, %uno
ret i1 %class
}
=>
define i1 @uge_smallest_normal_and_uno(half %x) nofree willreturn memory(none) {
#0:
%uno = fcmp uno half %x, 0x0000
ret i1 %uno
}
Transformation seems to be correct!
-- 332. PassManager<Function> : Skipping NOP
-- 333. PassManager<Function> : Skipping NOP
-- 334. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_finite(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %lt.infinity
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 335. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_finite(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %cmp.smallest.normal, %lt.infinity
ret i1 %class
}
=>
define i1 @olt_infinity_or_finite(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp one half %x, 0x7c00
ret i1 %lt.infinity
}
Transformation seems to be correct!
-- 336. PassManager<Function> : Skipping NOP
-- 337. PassManager<Function> : Skipping NOP
-- 338. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_finite(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %cmp.smallest.normal, %lt.infinity
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 339. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_finite(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %cmp.smallest.normal, %lt.infinity
ret i1 %class
}
=>
define i1 @olt_infinity_and_finite(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 252
ret i1 %class
}
Transformation seems to be correct!
-- 340. PassManager<Function> : Skipping NOP
-- 341. PassManager<Function> : Skipping NOP
-- 342. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%ord = fcmp ord half %x, 0x0400
%class = or i1 %lt.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 343. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%ord = fcmp ord half %x, 0x0400
%class = or i1 %lt.infinity, %ord
ret i1 %class
}
=>
define i1 @olt_infinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
ret i1 %ord
}
Transformation seems to be correct!
-- 344. PassManager<Function> : Skipping NOP
-- 345. PassManager<Function> : Skipping NOP
-- 346. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%uno = fcmp uno half %x, 0x0400
%class = or i1 %lt.infinity, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 347. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%uno = fcmp uno half %x, 0x0400
%class = or i1 %lt.infinity, %uno
ret i1 %class
}
=>
define i1 @olt_infinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp une half %x, 0x7c00
ret i1 %class
}
Transformation seems to be correct!
-- 348. PassManager<Function> : Skipping NOP
-- 349. PassManager<Function> : Skipping NOP
-- 350. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_subnormal(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%class = or i1 %lt.infinity, %is.subnormal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 351. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_subnormal(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%class = or i1 %lt.infinity, %is.subnormal
ret i1 %class
}
=>
define i1 @olt_infinity_or_subnormal(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp one half %x, 0x7c00
ret i1 %class
}
Transformation seems to be correct!
-- 352. PassManager<Function> : Skipping NOP
-- 353. PassManager<Function> : Skipping NOP
-- 354. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_subnormal(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%class = and i1 %lt.infinity, %is.subnormal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 355. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_subnormal(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%class = and i1 %lt.infinity, %is.subnormal
ret i1 %class
}
=>
define i1 @olt_infinity_and_subnormal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 240
ret i1 %class
}
Transformation seems to be correct!
-- 356. PassManager<Function> : Skipping NOP
-- 357. PassManager<Function> : Skipping NOP
-- 358. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_not_subnormal(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%not.subnormal = xor i1 %is.subnormal, 1
%class = and i1 %lt.infinity, %not.subnormal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 359. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_not_subnormal(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%not.subnormal = xor i1 %is.subnormal, 1
%class = and i1 %lt.infinity, %not.subnormal
ret i1 %class
}
=>
define i1 @olt_infinity_and_not_subnormal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 268
ret i1 %class
}
Transformation seems to be correct!
-- 360. PassManager<Function> : Skipping NOP
-- 361. PassManager<Function> : Skipping NOP
-- 362. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%eq.inf = fcmp ueq half %fabs, 0x7c00
%class = and i1 %lt.infinity, %eq.inf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 363. InstCombinePass
----------------------------------------
define i1 @olt_infinity_and_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%fabs = fabs half %x
%eq.inf = fcmp ueq half %fabs, 0x7c00
%class = and i1 %lt.infinity, %eq.inf
ret i1 %class
}
=>
define i1 @olt_infinity_and_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp oeq half %x, 0xfc00
ret i1 %class
}
Transformation seems to be correct!
-- 364. PassManager<Function> : Skipping NOP
-- 365. PassManager<Function> : Skipping NOP
-- 366. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%eq.inf = fcmp ueq half %x, 0x7c00
%class = or i1 %lt.infinity, %eq.inf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 367. InstCombinePass
----------------------------------------
define i1 @olt_infinity_or_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.infinity = fcmp olt half %x, 0x7c00
%eq.inf = fcmp ueq half %x, 0x7c00
%class = or i1 %lt.infinity, %eq.inf
ret i1 %class
}
=>
define i1 @olt_infinity_or_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 368. PassManager<Function> : Skipping NOP
-- 369. PassManager<Function> : Skipping NOP
-- 370. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp ueq half %x, 0x7c00
%class = or i1 %lt.normal, %eq.inf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 371. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp ueq half %x, 0x7c00
%class = or i1 %lt.normal, %eq.inf
ret i1 %class
}
=>
define i1 @olt_smallest_normal_or_ueq_inf(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 767
ret i1 %class
}
Transformation seems to be correct!
-- 372. PassManager<Function> : Skipping NOP
-- 373. PassManager<Function> : Skipping NOP
-- 374. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_une_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = or i1 %lt.normal, %eq.inf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 375. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_or_une_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = or i1 %lt.normal, %eq.inf
ret i1 %class
}
=>
define i1 @olt_smallest_normal_or_une_inf(half %x) nofree willreturn memory(none) {
#0:
%eq.inf = fcmp une half %x, 0x7c00
ret i1 %eq.inf
}
Transformation seems to be correct!
-- 376. PassManager<Function> : Skipping NOP
-- 377. PassManager<Function> : Skipping NOP
-- 378. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_and_une_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = and i1 %lt.normal, %eq.inf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 379. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_and_une_inf(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = and i1 %lt.normal, %eq.inf
ret i1 %class
}
=>
define i1 @olt_smallest_normal_and_une_inf(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 252
ret i1 %class
}
Transformation seems to be correct!
-- 380. PassManager<Function> : Skipping NOP
-- 381. PassManager<Function> : Skipping NOP
-- 382. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_and_une_inf_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = and i1 %lt.normal, %eq.inf
%eq.normal = fcmp oeq half %x, 0x0400
%eq.largest.normal = or i1 %eq.normal, %class
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 383. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_and_une_inf_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = and i1 %lt.normal, %eq.inf
ret i1 %class
}
=>
define i1 @olt_smallest_normal_and_une_inf_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 252
ret i1 %class
}
Transformation seems to be correct!
-- 384. PassManager<Function> : Skipping NOP
-- 385. PassManager<Function> : Skipping NOP
-- 386. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_and_une_inf_or_one_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = and i1 %lt.normal, %eq.inf
%ne.normal = fcmp one half %x, 0x0400
%eq.largest.normal = or i1 %ne.normal, %class
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 387. InstCombinePass
----------------------------------------
define i1 @olt_smallest_normal_and_une_inf_or_one_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%lt.normal = fcmp olt half %x, 0x0400
%eq.inf = fcmp une half %x, 0x7c00
%class = and i1 %lt.normal, %eq.inf
ret i1 %class
}
=>
define i1 @olt_smallest_normal_and_une_inf_or_one_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 252
ret i1 %class
}
Transformation seems to be correct!
-- 388. PassManager<Function> : Skipping NOP
-- 389. PassManager<Function> : Skipping NOP
-- 390. InstCombinePass
----------------------------------------
define i1 @oge_fabs_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%oge.fabs.inf = fcmp oge half %fabs, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %oge.fabs.inf, %ord
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 391. InstCombinePass
----------------------------------------
define i1 @oge_fabs_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%oge.fabs.inf = fcmp oge half %fabs, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %oge.fabs.inf, %ord
ret i1 %and
}
=>
define i1 @oge_fabs_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%oge.fabs.inf = fcmp oeq half %fabs, 0x7c00
ret i1 %oge.fabs.inf
}
Transformation seems to be correct!
-- 392. PassManager<Function> : Skipping NOP
-- 393. PassManager<Function> : Skipping NOP
-- 394. InstCombinePass
----------------------------------------
define i1 @oge_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%oge.fabs.inf = fcmp oge half %x, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %oge.fabs.inf, %ord
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 395. InstCombinePass
----------------------------------------
define i1 @oge_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%oge.fabs.inf = fcmp oge half %x, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %oge.fabs.inf, %ord
ret i1 %and
}
=>
define i1 @oge_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%oge.fabs.inf = fcmp oeq half %x, 0x7c00
ret i1 %oge.fabs.inf
}
Transformation seems to be correct!
-- 396. PassManager<Function> : Skipping NOP
-- 397. PassManager<Function> : Skipping NOP
-- 398. InstCombinePass
----------------------------------------
define i1 @oge_fabs_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%oge.fabs.inf = fcmp oge half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %oge.fabs.inf, %uno
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 399. InstCombinePass
----------------------------------------
define i1 @oge_fabs_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%oge.fabs.inf = fcmp oge half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %oge.fabs.inf, %uno
ret i1 %or
}
=>
define i1 @oge_fabs_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%#1 = fabs half %x
%or = fcmp ueq half %#1, 0x7c00
ret i1 %or
}
Transformation seems to be correct!
-- 400. PassManager<Function> : Skipping NOP
-- 401. PassManager<Function> : Skipping NOP
-- 402. InstCombinePass
----------------------------------------
define i1 @oge_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%oge.fabs.inf = fcmp oge half %x, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %oge.fabs.inf, %uno
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 403. InstCombinePass
----------------------------------------
define i1 @oge_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%oge.fabs.inf = fcmp oge half %x, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %oge.fabs.inf, %uno
ret i1 %or
}
=>
define i1 @oge_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%or = fcmp ueq half %x, 0x7c00
ret i1 %or
}
Transformation seems to be correct!
-- 404. PassManager<Function> : Skipping NOP
-- 405. PassManager<Function> : Skipping NOP
-- 406. InstCombinePass
----------------------------------------
define i1 @ult_fabs_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%ult.fabs.inf = fcmp ult half %fabs, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %ult.fabs.inf, %ord
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 407. InstCombinePass
----------------------------------------
define i1 @ult_fabs_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%ult.fabs.inf = fcmp ult half %fabs, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %ult.fabs.inf, %ord
ret i1 %and
}
=>
define i1 @ult_fabs_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%and = fcmp one half %fabs, 0x7c00
ret i1 %and
}
Transformation seems to be correct!
-- 408. PassManager<Function> : Skipping NOP
-- 409. PassManager<Function> : Skipping NOP
-- 410. InstCombinePass
----------------------------------------
define i1 @ult_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%ult.fabs.inf = fcmp ult half %x, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %ult.fabs.inf, %ord
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 411. InstCombinePass
----------------------------------------
define i1 @ult_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%ult.fabs.inf = fcmp ult half %x, 0x7c00
%ord = fcmp ord half %x, 0x0000
%and = and i1 %ult.fabs.inf, %ord
ret i1 %and
}
=>
define i1 @ult_eq_inf_and_ord(half %x) nofree willreturn memory(none) {
#0:
%and = fcmp one half %x, 0x7c00
ret i1 %and
}
Transformation seems to be correct!
-- 412. PassManager<Function> : Skipping NOP
-- 413. PassManager<Function> : Skipping NOP
-- 414. InstCombinePass
----------------------------------------
define i1 @ult_fabs_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%ult.fabs.inf = fcmp ult half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %ult.fabs.inf, %uno
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 415. InstCombinePass
----------------------------------------
define i1 @ult_fabs_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%ult.fabs.inf = fcmp ult half %fabs, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %ult.fabs.inf, %uno
ret i1 %or
}
=>
define i1 @ult_fabs_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%ult.fabs.inf = fcmp une half %fabs, 0x7c00
ret i1 %ult.fabs.inf
}
Transformation seems to be correct!
-- 416. PassManager<Function> : Skipping NOP
-- 417. PassManager<Function> : Skipping NOP
-- 418. InstCombinePass
----------------------------------------
define i1 @ult_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%ult.fabs.inf = fcmp ult half %x, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %ult.fabs.inf, %uno
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 419. InstCombinePass
----------------------------------------
define i1 @ult_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%ult.fabs.inf = fcmp ult half %x, 0x7c00
%uno = fcmp uno half %x, 0x0000
%or = or i1 %ult.fabs.inf, %uno
ret i1 %or
}
=>
define i1 @ult_eq_inf_or_uno(half %x) nofree willreturn memory(none) {
#0:
%ult.fabs.inf = fcmp une half %x, 0x7c00
ret i1 %ult.fabs.inf
}
Transformation seems to be correct!
-- 420. PassManager<Function> : Skipping NOP
-- 421. PassManager<Function> : Skipping NOP
-- 422. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = or i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 423. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = or i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 424. PassManager<Function> : Skipping NOP
-- 425. PassManager<Function> : Skipping NOP
-- 426. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 427. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @oeq_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 252
ret i1 %class
}
Transformation seems to be correct!
-- 428. PassManager<Function> : Skipping NOP
-- 429. PassManager<Function> : Skipping NOP
-- 430. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 431. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @oeq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
ret i1 %oeq.neg.infinity
}
Transformation seems to be correct!
-- 432. PassManager<Function> : Skipping NOP
-- 433. PassManager<Function> : Skipping NOP
-- 434. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp oge half %x, 0x0400
%class = or i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 435. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp oge half %x, 0x0400
%class = or i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @oeq_neginfinity_or_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 772
ret i1 %class
}
Transformation seems to be correct!
-- 436. PassManager<Function> : Skipping NOP
-- 437. PassManager<Function> : Skipping NOP
-- 438. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_and_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp oge half %x, 0x0400
%class = and i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 439. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_and_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%cmp.smallest.normal = fcmp oge half %x, 0x0400
%class = and i1 %oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @oeq_neginfinity_and_oge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 440. PassManager<Function> : Skipping NOP
-- 441. PassManager<Function> : Skipping NOP
-- 442. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = or i1 %oeq.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 443. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = or i1 %oeq.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @oeq_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp ord half %x, 0x0000
ret i1 %class
}
Transformation seems to be correct!
-- 444. PassManager<Function> : Skipping NOP
-- 445. PassManager<Function> : Skipping NOP
-- 446. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = and i1 %oeq.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 447. InstCombinePass
----------------------------------------
define i1 @oeq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = and i1 %oeq.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @oeq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%oeq.neg.infinity = fcmp oeq half %x, 0xfc00
ret i1 %oeq.neg.infinity
}
Transformation seems to be correct!
-- 448. PassManager<Function> : Skipping NOP
-- 449. PassManager<Function> : Skipping NOP
-- 450. InstCombinePass
----------------------------------------
define i1 @une_neginfinity_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%une.neg.infinity = fcmp une half %x, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = or i1 %une.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 451. InstCombinePass
----------------------------------------
define i1 @une_neginfinity_or_oeq_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%une.neg.infinity = fcmp une half %x, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = or i1 %une.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 452. PassManager<Function> : Skipping NOP
-- 453. PassManager<Function> : Skipping NOP
-- 454. InstCombinePass
----------------------------------------
define i1 @une_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%une.neg.infinity = fcmp une half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = or i1 %une.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 455. InstCombinePass
----------------------------------------
define i1 @une_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%une.neg.infinity = fcmp une half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = or i1 %une.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @une_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 456. PassManager<Function> : Skipping NOP
-- 457. PassManager<Function> : Skipping NOP
-- 458. InstCombinePass
----------------------------------------
define i1 @une_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%une.neg.infinity = fcmp une half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = and i1 %une.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 459. InstCombinePass
----------------------------------------
define i1 @une_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%une.neg.infinity = fcmp une half %x, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = and i1 %une.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @une_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp one half %x, 0xfc00
ret i1 %class
}
Transformation seems to be correct!
-- 460. PassManager<Function> : Skipping NOP
-- 461. PassManager<Function> : Skipping NOP
-- 462. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 463. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @one_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp ord half %x, 0x0000
ret i1 %class
}
Transformation seems to be correct!
-- 464. PassManager<Function> : Skipping NOP
-- 465. PassManager<Function> : Skipping NOP
-- 466. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 467. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @one_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 248
ret i1 %class
}
Transformation seems to be correct!
-- 468. PassManager<Function> : Skipping NOP
-- 469. PassManager<Function> : Skipping NOP
-- 470. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%uno = fcmp uno half %x, 0x0000
%class = or i1 %one.neg.infinity, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 471. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%uno = fcmp uno half %x, 0x0000
%class = or i1 %one.neg.infinity, %uno
ret i1 %class
}
=>
define i1 @one_neginfinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp une half %x, 0xfc00
ret i1 %class
}
Transformation seems to be correct!
-- 472. PassManager<Function> : Skipping NOP
-- 473. PassManager<Function> : Skipping NOP
-- 474. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%ord = fcmp uno half %x, 0x0000
%class = and i1 %one.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 475. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%ord = fcmp uno half %x, 0x0000
%class = and i1 %one.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @one_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 476. PassManager<Function> : Skipping NOP
-- 477. PassManager<Function> : Skipping NOP
-- 478. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 479. InstCombinePass
----------------------------------------
define i1 @one_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%one.neg.infinity = fcmp one half %x, 0xfc00
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @one_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 768
ret i1 %class
}
Transformation seems to be correct!
-- 480. PassManager<Function> : Skipping NOP
-- 481. PassManager<Function> : Skipping NOP
-- 482. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 483. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @ueq_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 255
ret i1 %class
}
Transformation seems to be correct!
-- 484. PassManager<Function> : Skipping NOP
-- 485. PassManager<Function> : Skipping NOP
-- 486. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 487. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @ueq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp oeq half %x, 0xfc00
ret i1 %class
}
Transformation seems to be correct!
-- 488. PassManager<Function> : Skipping NOP
-- 489. PassManager<Function> : Skipping NOP
-- 490. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%uno = fcmp uno half %x, 0x0000
%class = or i1 %ueq.neg.infinity, %uno
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 491. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%uno = fcmp uno half %x, 0x0000
%class = or i1 %ueq.neg.infinity, %uno
ret i1 %class
}
=>
define i1 @ueq_neginfinity_or_uno(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
ret i1 %ueq.neg.infinity
}
Transformation seems to be correct!
-- 492. PassManager<Function> : Skipping NOP
-- 493. PassManager<Function> : Skipping NOP
-- 494. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%ord = fcmp uno half %x, 0x0000
%class = and i1 %ueq.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 495. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%ord = fcmp uno half %x, 0x0000
%class = and i1 %ueq.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @ueq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp uno half %x, 0x0000
ret i1 %ord
}
Transformation seems to be correct!
-- 496. PassManager<Function> : Skipping NOP
-- 497. PassManager<Function> : Skipping NOP
-- 498. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 499. InstCombinePass
----------------------------------------
define i1 @ueq_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%ueq.neg.infinity = fcmp ueq half %x, 0xfc00
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @ueq_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp uno half %x, 0x0000
ret i1 %class
}
Transformation seems to be correct!
-- 500. PassManager<Function> : Skipping NOP
-- 501. PassManager<Function> : Skipping NOP
-- 502. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = or i1 %fabs.oeq.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 503. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = or i1 %fabs.oeq.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @fabs_oeq_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp ord half %x, 0x0000
ret i1 %ord
}
Transformation seems to be correct!
-- 504. PassManager<Function> : Skipping NOP
-- 505. PassManager<Function> : Skipping NOP
-- 506. InstCombinePass
----------------------------------------
define i1 @fabs_une_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.une.neg.infinity = fcmp une half %fabs, 0xfc00
%ord = fcmp une half %x, 0x0000
%class = or i1 %fabs.une.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 507. InstCombinePass
----------------------------------------
define i1 @fabs_une_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.une.neg.infinity = fcmp une half %fabs, 0xfc00
%ord = fcmp une half %x, 0x0000
%class = or i1 %fabs.une.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @fabs_une_neginfinity_or_ord(half %x) nofree willreturn memory(none) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 508. PassManager<Function> : Skipping NOP
-- 509. PassManager<Function> : Skipping NOP
-- 510. InstCombinePass
----------------------------------------
define i1 @fabs_une_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.une.neg.infinity = fcmp une half %fabs, 0xfc00
%ord = fcmp une half %x, 0x0000
%class = and i1 %fabs.une.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 511. InstCombinePass
----------------------------------------
define i1 @fabs_une_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.une.neg.infinity = fcmp une half %fabs, 0xfc00
%ord = fcmp une half %x, 0x0000
%class = and i1 %fabs.une.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @fabs_une_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%ord = fcmp une half %x, 0x0000
ret i1 %ord
}
Transformation seems to be correct!
-- 512. PassManager<Function> : Skipping NOP
-- 513. PassManager<Function> : Skipping NOP
-- 514. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = and i1 %fabs.oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 515. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = and i1 %fabs.oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @fabs_oeq_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 516. PassManager<Function> : Skipping NOP
-- 517. PassManager<Function> : Skipping NOP
-- 518. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_or_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = or i1 %fabs.oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 519. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_or_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
%class = or i1 %fabs.oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @fabs_oeq_neginfinity_or_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%cmp.smallest.normal = fcmp oeq half %x, 0x0400
ret i1 %cmp.smallest.normal
}
Transformation seems to be correct!
-- 520. PassManager<Function> : Skipping NOP
-- 521. PassManager<Function> : Skipping NOP
-- 522. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = and i1 %fabs.oeq.neg.infinity, %ord
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 523. InstCombinePass
----------------------------------------
define i1 @fabs_oeq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp oeq half %fabs, 0xfc00
%ord = fcmp ord half %x, 0x0000
%class = and i1 %fabs.oeq.neg.infinity, %ord
ret i1 %class
}
=>
define i1 @fabs_oeq_neginfinity_and_ord(half %x) nofree willreturn memory(none) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 524. PassManager<Function> : Skipping NOP
-- 525. PassManager<Function> : Skipping NOP
-- 526. InstCombinePass
----------------------------------------
define i1 @fabs_ueq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.ueq.neg.infinity = fcmp ueq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %fabs.ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 527. InstCombinePass
----------------------------------------
define i1 @fabs_ueq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.ueq.neg.infinity = fcmp ueq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = and i1 %fabs.ueq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @fabs_ueq_neginfinity_and_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 528. PassManager<Function> : Skipping NOP
-- 529. PassManager<Function> : Skipping NOP
-- 530. InstCombinePass
----------------------------------------
define i1 @fabs_one_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.one.neg.infinity = fcmp one half %fabs, 0xfc00
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %fabs.one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 531. InstCombinePass
----------------------------------------
define i1 @fabs_one_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.one.neg.infinity = fcmp one half %fabs, 0xfc00
%cmp.smallest.normal = fcmp uge half %x, 0x0400
%class = and i1 %fabs.one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @fabs_one_neginfinity_and_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 768
ret i1 %class
}
Transformation seems to be correct!
-- 532. PassManager<Function> : Skipping NOP
-- 533. PassManager<Function> : Skipping NOP
-- 534. InstCombinePass
----------------------------------------
define i1 @fabs_one_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.one.neg.infinity = fcmp one half %fabs, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %fabs.one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 535. InstCombinePass
----------------------------------------
define i1 @fabs_one_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.one.neg.infinity = fcmp one half %fabs, 0xfc00
%cmp.smallest.normal = fcmp olt half %x, 0x0400
%class = or i1 %fabs.one.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @fabs_one_neginfinity_or_olt_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = fcmp ord half %x, 0x0000
ret i1 %class
}
Transformation seems to be correct!
-- 536. PassManager<Function> : Skipping NOP
-- 537. PassManager<Function> : Skipping NOP
-- 538. InstCombinePass
----------------------------------------
define i1 @fabs_ueq_neginfinity_or_fabs_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp ueq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%class = or i1 %fabs.oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 539. InstCombinePass
----------------------------------------
define i1 @fabs_ueq_neginfinity_or_fabs_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%fabs.oeq.neg.infinity = fcmp ueq half %fabs, 0xfc00
%cmp.smallest.normal = fcmp uge half %fabs, 0x0400
%class = or i1 %fabs.oeq.neg.infinity, %cmp.smallest.normal
ret i1 %class
}
=>
define i1 @fabs_ueq_neginfinity_or_fabs_uge_smallest_normal(half %x) nofree willreturn memory(none) {
#0:
%class = is.fpclass half %x, i32 783
ret i1 %class
}
Transformation seems to be correct!
-- 540. PassManager<Function> : Skipping NOP
-- 541. PassManager<Function> : Skipping NOP
-- 542. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 543. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 544. PassManager<Function> : Skipping NOP
-- 545. PassManager<Function> : Skipping NOP
-- 546. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_daz(<2 x half> %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 547. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_daz(<2 x half> %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 548. PassManager<Function> : Skipping NOP
-- 549. PassManager<Function> : Skipping NOP
-- 550. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_dynamic(half %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 551. InstCombinePass
----------------------------------------
define i1 @not_isfinite_or_zero_f16_dynamic(half %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs half %x
%cmpinf = fcmp ueq half %fabs, 0x7c00
%cmpzero = fcmp oeq half %x, 0x0000
%class = or i1 %cmpzero, %cmpinf
ret i1 %class
}
Transformation seems to be correct! (syntactically equal)
-- 552. PassManager<Function> : Skipping NOP
-- 553. PassManager<Function> : Skipping NOP
-- 554. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_dynamic(<2 x half> %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 555. InstCombinePass
----------------------------------------
define <2 x i1> @not_isfinite_or_zero_v2f16_dynamic(<2 x half> %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs <2 x half> %x
%cmpinf = fcmp ueq <2 x half> %fabs, { 0x7c00, 0x7c00 }
%cmpzero = fcmp oeq <2 x half> %x, { 0x0000, 0x0000 }
%class = or <2 x i1> %cmpzero, %cmpinf
ret <2 x i1> %class
}
Transformation seems to be correct! (syntactically equal)
-- 556. PassManager<Function> : Skipping NOP
-- 557. PassManager<Function> : Skipping NOP
-- 558. InstCombinePass
----------------------------------------
define i1 @not_zero_and_subnormal_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %fabs, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 559. InstCombinePass
----------------------------------------
define i1 @not_zero_and_subnormal_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %fabs, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
=>
define i1 @not_zero_and_subnormal_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%or = fcmp ord half %x, 0x0000
ret i1 %or
}
Transformation seems to be correct!
-- 560. PassManager<Function> : Skipping NOP
-- 561. PassManager<Function> : Skipping NOP
-- 562. InstCombinePass
----------------------------------------
define i1 @not_zero_and_subnormal_dynamic(half %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %fabs, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 563. InstCombinePass
----------------------------------------
define i1 @not_zero_and_subnormal_dynamic(half %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %fabs, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
=>
define i1 @not_zero_and_subnormal_dynamic(half %x) denormal-fp-math=ieee,dynamic {
#0:
%fabs = fabs half %x
%cmp.zero = fcmp one half %x, 0x0000
%cmp.smallest.normal = fcmp olt half %fabs, 0x0400
%or = or i1 %cmp.smallest.normal, %cmp.zero
ret i1 %or
}
Transformation seems to be correct!
-- 564. PassManager<Function> : Skipping NOP
-- 565. PassManager<Function> : Skipping NOP
-- 566. InstCombinePass
----------------------------------------
define i1 @subnormal_or_zero_ieee(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%is.zero = fcmp oeq half %x, 0x0000
%and = or i1 %is.subnormal, %is.zero
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 567. InstCombinePass
----------------------------------------
define i1 @subnormal_or_zero_ieee(half %x) nofree willreturn memory(none) {
#0:
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%is.zero = fcmp oeq half %x, 0x0000
%and = or i1 %is.subnormal, %is.zero
ret i1 %and
}
=>
define i1 @subnormal_or_zero_ieee(half %x) nofree willreturn memory(none) {
#0:
%and = is.fpclass half %x, i32 240
ret i1 %and
}
Transformation seems to be correct!
-- 568. PassManager<Function> : Skipping NOP
-- 569. PassManager<Function> : Skipping NOP
-- 570. InstCombinePass
----------------------------------------
define i1 @subnormal_or_zero_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%is.zero = fcmp oeq half %x, 0x0000
%and = or i1 %is.subnormal, %is.zero
ret i1 %and
}
Transformation seems to be correct! (syntactically equal)
-- 571. InstCombinePass
----------------------------------------
define i1 @subnormal_or_zero_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%fabs = fabs half %x
%is.subnormal = fcmp olt half %fabs, 0x0400
%is.zero = fcmp oeq half %x, 0x0000
%and = or i1 %is.subnormal, %is.zero
ret i1 %and
}
=>
define i1 @subnormal_or_zero_daz(half %x) denormal-fp-math=ieee,preserve-sign {
#0:
%is.subnormal = fcmp oeq half %x, 0x0000
ret i1 %is.subnormal
}
Transformation doesn't verify! (unsound)
ERROR: Target's return value is more undefined
Example:
half %x = #x0001 (0.000000059604?)
Source:
half %fabs = #x0001 (0.000000059604?)
i1 %is.subnormal = #x1 (1)
i1 %is.zero = #x0 (0)
i1 %and = #x1 (1)
Target:
i1 %is.subnormal = #x1 (1)
Source value: #x1 (1)
Target value: #x1 (1)
Pass: InstCombinePass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-S' '-passes=instcombine' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_oDvLLo3Y_9hiv.bc"
------------------- SMT STATS -------------------
Num queries: 500
Num invalid: 0
Num skips: 0
Num trivial: 537 (51.8%)
Num timeout: 0 (0.0%)
Num errors: 0 (0.0%)
Num SAT: 263 (52.6%)
Num UNSAT: 237 (47.4%)
Alive2: Transform doesn't verify; aborting!
Transforms/InstCombine/create-class-from-logic-fcmp.ll' FAILED ******************** Exit Code: 2 Command Output (stdout): -- # RUN: at line 2 /home/nlopes/alive2/build/opt-alive.sh -S -passes=instcombine < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/create-class-from-logic-fcmp.ll | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/create-class-from-logic-fcmp.ll # executed command: /home/nlopes/alive2/build/opt-alive.sh -S -passes=instcombine # .---command stderr------------ # `----------------------------- # error: command failed with exit status: 1 # executed command: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/create-class-from-logic-fcmp.ll # .---command stderr------------ # | FileCheck error: '<stdin>' is empty. # | FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/create-class-from-logic-fcmp.ll # `----------------------------- # error: command failed with exit status: 2 --