Test source: git
Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstSimplifyPass
----------------------------------------
define float @fneg_fneg_var(float %a) {
#0:
%r = fneg float %a
%r1 = fneg float %r
ret float %r1
}
Transformation seems to be correct! (syntactically equal)
-- 3. InstSimplifyPass
----------------------------------------
define float @fneg_fneg_var(float %a) {
#0:
%r = fneg float %a
%r1 = fneg float %r
ret float %r1
}
=>
define float @fneg_fneg_var(float %a) {
#0:
ret float %a
}
Transformation seems to be correct!
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstSimplifyPass
----------------------------------------
define float @fsub_-0_x(float %a) {
#0:
%t1 = fsub float -0.000000, %a
%ret = fneg float %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 7. InstSimplifyPass
----------------------------------------
define float @fsub_-0_x(float %a) {
#0:
%t1 = fsub float -0.000000, %a
%ret = fneg float %t1
ret float %ret
}
=>
define float @fsub_-0_x(float %a) {
#0:
ret float %a
}
Transformation seems to be correct!
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_x_vec(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { -0.000000, -0.000000 }, %a
%ret = fneg <2 x float> %t1
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 11. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_x_vec(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { -0.000000, -0.000000 }, %a
%ret = fneg <2 x float> %t1
ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_x_vec(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_x_vec_poison_elts(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { -0.000000, poison }, %a
%ret = fneg <2 x float> %t1
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 15. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_x_vec_poison_elts(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { -0.000000, poison }, %a
%ret = fneg <2 x float> %t1
ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_x_vec_poison_elts(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation seems to be correct!
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_negzero_vec_poison_elts(<2 x float> %x) {
#0:
%r = fsub nsz <2 x float> %x, { poison, -0.000000 }
ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)
-- 19. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_negzero_vec_poison_elts(<2 x float> %x) {
#0:
%r = fsub nsz <2 x float> %x, { poison, -0.000000 }
ret <2 x float> %r
}
=>
define <2 x float> @fsub_negzero_vec_poison_elts(<2 x float> %x) {
#0:
ret <2 x float> %x
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstSimplifyPass
----------------------------------------
define float @fsub_-0_-0_x(float %a) {
#0:
%t1 = fsub float -0.000000, %a
%ret = fsub float -0.000000, %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 23. InstSimplifyPass
----------------------------------------
define float @fsub_-0_-0_x(float %a) {
#0:
%t1 = fsub float -0.000000, %a
%ret = fsub float -0.000000, %t1
ret float %ret
}
=>
define float @fsub_-0_-0_x(float %a) {
#0:
ret float %a
}
Transformation seems to be correct!
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstSimplifyPass
----------------------------------------
define float @fneg_x(float %a) {
#0:
%t1 = fneg float %a
%ret = fsub float -0.000000, %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 27. InstSimplifyPass
----------------------------------------
define float @fneg_x(float %a) {
#0:
%t1 = fneg float %a
%ret = fsub float -0.000000, %t1
ret float %ret
}
=>
define float @fneg_x(float %a) {
#0:
ret float %a
}
Transformation seems to be correct!
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_-0_x_vec(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { -0.000000, -0.000000 }, %a
%ret = fsub <2 x float> { -0.000000, -0.000000 }, %t1
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 31. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_-0_x_vec(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { -0.000000, -0.000000 }, %a
%ret = fsub <2 x float> { -0.000000, -0.000000 }, %t1
ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_-0_x_vec(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstSimplifyPass
----------------------------------------
define <2 x float> @fneg_x_vec(<2 x float> %a) {
#0:
%t1 = fneg <2 x float> %a
%ret = fsub <2 x float> { -0.000000, -0.000000 }, %t1
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 35. InstSimplifyPass
----------------------------------------
define <2 x float> @fneg_x_vec(<2 x float> %a) {
#0:
%t1 = fneg <2 x float> %a
%ret = fsub <2 x float> { -0.000000, -0.000000 }, %t1
ret <2 x float> %ret
}
=>
define <2 x float> @fneg_x_vec(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_-0_x_vec_poison_elts(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { poison, -0.000000 }, %a
%ret = fsub <2 x float> { -0.000000, poison }, %t1
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 39. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_-0_-0_x_vec_poison_elts(<2 x float> %a) {
#0:
%t1 = fsub <2 x float> { poison, -0.000000 }, %a
%ret = fsub <2 x float> { -0.000000, poison }, %t1
ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_-0_x_vec_poison_elts(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation seems to be correct!
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstSimplifyPass
----------------------------------------
define <2 x float> @fneg_x_vec_poison_elts(<2 x float> %a) {
#0:
%t1 = fneg <2 x float> %a
%ret = fsub <2 x float> { -0.000000, poison }, %t1
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 43. InstSimplifyPass
----------------------------------------
define <2 x float> @fneg_x_vec_poison_elts(<2 x float> %a) {
#0:
%t1 = fneg <2 x float> %a
%ret = fsub <2 x float> { -0.000000, poison }, %t1
ret <2 x float> %ret
}
=>
define <2 x float> @fneg_x_vec_poison_elts(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation seems to be correct!
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstSimplifyPass
----------------------------------------
define float @fsub_-0_0_x(float %a) {
#0:
%t1 = fsub float 0.000000, %a
%ret = fsub float -0.000000, %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 47. InstSimplifyPass
----------------------------------------
define float @fsub_-0_0_x(float %a) {
#0:
%t1 = fsub float 0.000000, %a
%ret = fsub float -0.000000, %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InstSimplifyPass
----------------------------------------
define float @fsub_0_-0_x(float %a) {
#0:
%t1 = fsub float -0.000000, %a
%ret = fsub float 0.000000, %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 51. InstSimplifyPass
----------------------------------------
define float @fsub_0_-0_x(float %a) {
#0:
%t1 = fsub float -0.000000, %a
%ret = fsub float 0.000000, %t1
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstSimplifyPass
----------------------------------------
define float @fsub_x_0(float %x) {
#0:
%r = fsub float %x, 0.000000
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 55. InstSimplifyPass
----------------------------------------
define float @fsub_x_0(float %x) {
#0:
%r = fsub float %x, 0.000000
ret float %r
}
=>
define float @fsub_x_0(float %x) {
#0:
ret float %x
}
Transformation seems to be correct!
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_x_0_vec_poison(<2 x float> %x) {
#0:
%r = fsub <2 x float> %x, { poison, 0.000000 }
ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)
-- 59. InstSimplifyPass
----------------------------------------
define <2 x float> @fsub_x_0_vec_poison(<2 x float> %x) {
#0:
%r = fsub <2 x float> %x, { poison, 0.000000 }
ret <2 x float> %r
}
=>
define <2 x float> @fsub_x_0_vec_poison(<2 x float> %x) {
#0:
ret <2 x float> %x
}
Transformation seems to be correct!
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstSimplifyPass
----------------------------------------
define float @fadd_x_n0(float %a) {
#0:
%ret = fadd float %a, -0.000000
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 63. InstSimplifyPass
----------------------------------------
define float @fadd_x_n0(float %a) {
#0:
%ret = fadd float %a, -0.000000
ret float %ret
}
=>
define float @fadd_x_n0(float %a) {
#0:
ret float %a
}
Transformation seems to be correct!
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstSimplifyPass
----------------------------------------
define <2 x float> @fadd_x_n0_vec_poison_elt(<2 x float> %a) {
#0:
%ret = fadd <2 x float> %a, { -0.000000, poison }
ret <2 x float> %ret
}
Transformation seems to be correct! (syntactically equal)
-- 67. InstSimplifyPass
----------------------------------------
define <2 x float> @fadd_x_n0_vec_poison_elt(<2 x float> %a) {
#0:
%ret = fadd <2 x float> %a, { -0.000000, poison }
ret <2 x float> %ret
}
=>
define <2 x float> @fadd_x_n0_vec_poison_elt(<2 x float> %a) {
#0:
ret <2 x float> %a
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstSimplifyPass
----------------------------------------
define double @fmul_X_1(double %a) {
#0:
%b = fmul double 1.000000, %a
ret double %b
}
Transformation seems to be correct! (syntactically equal)
-- 71. InstSimplifyPass
----------------------------------------
define double @fmul_X_1(double %a) {
#0:
%b = fmul double 1.000000, %a
ret double %b
}
=>
define double @fmul_X_1(double %a) {
#0:
ret double %a
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstSimplifyPass
----------------------------------------
define half @fmul_nnan_ninf_nneg_0.0(i15 %x) {
#0:
%f = uitofp i15 %x to half
%r = fmul half %f, 0x0000
ret half %r
}
Transformation seems to be correct! (syntactically equal)
-- 75. InstSimplifyPass
----------------------------------------
define half @fmul_nnan_ninf_nneg_0.0(i15 %x) {
#0:
%f = uitofp i15 %x to half
%r = fmul half %f, 0x0000
ret half %r
}
=>
define half @fmul_nnan_ninf_nneg_0.0(i15 %x) {
#0:
ret half 0x0000
}
Transformation seems to be correct!
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstSimplifyPass
----------------------------------------
define half @fmul_nnan_ninf_nneg_n0.0(i15 %x) {
#0:
%f = uitofp i15 %x to half
%r = fmul half %f, 0x8000
ret half %r
}
Transformation seems to be correct! (syntactically equal)
-- 79. InstSimplifyPass
----------------------------------------
define half @fmul_nnan_ninf_nneg_n0.0(i15 %x) {
#0:
%f = uitofp i15 %x to half
%r = fmul half %f, 0x8000
ret half %r
}
=>
define half @fmul_nnan_ninf_nneg_n0.0(i15 %x) {
#0:
ret half 0x8000
}
Transformation seems to be correct!
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstSimplifyPass
----------------------------------------
define half @fmul_nnan_nneg_0.0(i16 %x) {
#0:
%f = uitofp i16 %x to half
%r = fmul half %f, 0x0000
ret half %r
}
Transformation seems to be correct! (syntactically equal)
-- 83. InstSimplifyPass
----------------------------------------
define half @fmul_nnan_nneg_0.0(i16 %x) {
#0:
%f = uitofp i16 %x to half
%r = fmul half %f, 0x0000
ret half %r
}
Transformation seems to be correct! (syntactically equal)
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstSimplifyPass
----------------------------------------
define double @fmul_nnan_ninf_nneg_n0.0_commute(i127 %x) {
#0:
%f = uitofp i127 %x to float
%e = fpext float %f to double
%r = fmul double -0.000000, %e
ret double %r
}
Transformation seems to be correct! (syntactically equal)
-- 87. InstSimplifyPass
----------------------------------------
define double @fmul_nnan_ninf_nneg_n0.0_commute(i127 %x) {
#0:
%f = uitofp i127 %x to float
%e = fpext float %f to double
%r = fmul double -0.000000, %e
ret double %r
}
=>
define double @fmul_nnan_ninf_nneg_n0.0_commute(i127 %x) {
#0:
ret double -0.000000
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstSimplifyPass
----------------------------------------
define float @src_mul_nzero_neg(float nofpclass(967) %f) {
#0:
%r = fmul float nofpclass(967) %f, -0.000000
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 91. InstSimplifyPass
----------------------------------------
define float @src_mul_nzero_neg(float nofpclass(967) %f) {
#0:
%r = fmul float nofpclass(967) %f, -0.000000
ret float %r
}
=>
define float @src_mul_nzero_neg(float nofpclass(967) %f) {
#0:
ret float 0.000000
}
Transformation seems to be correct!
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstSimplifyPass
----------------------------------------
define <2 x float> @src_mul_zero_neg(<2 x float> nofpclass(967) %f) {
#0:
%r = fmul <2 x float> { 0.000000, 0.000000 }, nofpclass(967) %f
ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)
-- 95. InstSimplifyPass
----------------------------------------
define <2 x float> @src_mul_zero_neg(<2 x float> nofpclass(967) %f) {
#0:
%r = fmul <2 x float> { 0.000000, 0.000000 }, nofpclass(967) %f
ret <2 x float> %r
}
=>
define <2 x float> @src_mul_zero_neg(<2 x float> nofpclass(967) %f) {
#0:
ret <2 x float> { -0.000000, -0.000000 }
}
Transformation seems to be correct!
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstSimplifyPass
----------------------------------------
define <2 x float> @src_mul_zero_and_nzero_neg(<2 x float> nofpclass(967) %f) {
#0:
%r = fmul <2 x float> { -0.000000, 0.000000 }, nofpclass(967) %f
ret <2 x float> %r
}
Transformation seems to be correct! (syntactically equal)
-- 99. InstSimplifyPass
----------------------------------------
define <2 x float> @src_mul_zero_and_nzero_neg(<2 x float> nofpclass(967) %f) {
#0:
%r = fmul <2 x float> { -0.000000, 0.000000 }, nofpclass(967) %f
ret <2 x float> %r
}
=>
define <2 x float> @src_mul_zero_and_nzero_neg(<2 x float> nofpclass(967) %f) {
#0:
ret <2 x float> { 0.000000, -0.000000 }
}
Transformation seems to be correct!
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. InstSimplifyPass
----------------------------------------
define float @src_muladd_zero_neg(float nofpclass(967) %f, float %add) {
#0:
%r = fmuladd float nofpclass(967) %f, float 0.000000, float %add
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 103. InstSimplifyPass
----------------------------------------
define float @src_muladd_zero_neg(float nofpclass(967) %f, float %add) {
#0:
%r = fmuladd float nofpclass(967) %f, float 0.000000, float %add
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstSimplifyPass
----------------------------------------
define float @src_fma_nzero_neg(float nofpclass(967) %f, float %add) {
#0:
%r = fma float -0.000000, float nofpclass(967) %f, float %add
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 107. InstSimplifyPass
----------------------------------------
define float @src_fma_nzero_neg(float nofpclass(967) %f, float %add) {
#0:
%r = fma float -0.000000, float nofpclass(967) %f, float %add
ret float %r
}
Transformation seems to be correct! (syntactically equal)
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstSimplifyPass
----------------------------------------
define {float, float} @test_fmul_0_assumed_finite(float %x) {
#0:
%fabs.x = fabs float %x
%is.finite.x = fcmp one float %fabs.x, inf
assume i1 %is.finite.x
%mul.0 = fmul float %fabs.x, 0.000000
%mul.neg0 = fmul float %fabs.x, -0.000000
%ins.0 = insertvalue {float, float} poison, float %mul.0, 0
%ins.1 = insertvalue {float, float} %ins.0, float %mul.neg0, 1
ret {float, float} %ins.1
}
Transformation seems to be correct! (syntactically equal)
-- 111. InstSimplifyPass
----------------------------------------
define {float, float} @test_fmul_0_assumed_finite(float %x) {
#0:
%fabs.x = fabs float %x
%is.finite.x = fcmp one float %fabs.x, inf
assume i1 %is.finite.x
%mul.0 = fmul float %fabs.x, 0.000000
%mul.neg0 = fmul float %fabs.x, -0.000000
%ins.0 = insertvalue {float, float} poison, float %mul.0, 0
%ins.1 = insertvalue {float, float} %ins.0, float %mul.neg0, 1
ret {float, float} %ins.1
}
=>
define {float, float} @test_fmul_0_assumed_finite(float %x) {
#0:
%fabs.x = fabs float %x
%is.finite.x = fcmp one float %fabs.x, inf
assume i1 %is.finite.x
ret {float, float} { 0.000000, -0.000000 }
}
Transformation seems to be correct!
-- 112. PassManager<Function> : Skipping NOP
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstSimplifyPass
----------------------------------------
define double @fmul_nnan_ninf_nneg_0.0_commute(i128 %x) {
#0:
%f = uitofp i128 %x to float
%e = fpext float %f to double
%r = fmul double 0.000000, %e
ret double %r
}
Transformation seems to be correct! (syntactically equal)
-- 115. InstSimplifyPass
----------------------------------------
define double @fmul_nnan_ninf_nneg_0.0_commute(i128 %x) {
#0:
%f = uitofp i128 %x to float
%e = fpext float %f to double
%r = fmul double 0.000000, %e
ret double %r
}
Transformation seems to be correct! (syntactically equal)
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstSimplifyPass
----------------------------------------
define <4 x float> @fmul_X_1_vec(<4 x float> %x) {
#0:
%m = fmul <4 x float> %x, { 1.000000, 1.000000, 1.000000, 1.000000 }
ret <4 x float> %m
}
Transformation seems to be correct! (syntactically equal)
-- 119. InstSimplifyPass
----------------------------------------
define <4 x float> @fmul_X_1_vec(<4 x float> %x) {
#0:
%m = fmul <4 x float> %x, { 1.000000, 1.000000, 1.000000, 1.000000 }
ret <4 x float> %m
}
=>
define <4 x float> @fmul_X_1_vec(<4 x float> %x) {
#0:
ret <4 x float> %x
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstSimplifyPass
----------------------------------------
define float @fdiv_x_1(float %a) {
#0:
%ret = fdiv float %a, 1.000000
ret float %ret
}
Transformation seems to be correct! (syntactically equal)
-- 123. InstSimplifyPass
----------------------------------------
define float @fdiv_x_1(float %a) {
#0:
%ret = fdiv float %a, 1.000000
ret float %ret
}
=>
define float @fdiv_x_1(float %a) {
#0:
ret float %a
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstSimplifyPass
----------------------------------------
declare float @sqrtf(float)
define float @PR22688(float %x) {
#0:
assume_welldefined float %x
%#1 = sqrt float %x
assume_welldefined float %#1
%#2 = sqrt float %#1
assume_welldefined float %#2
%#3 = sqrt float %#2
assume_welldefined float %#3
%#4 = sqrt float %#3
assume_welldefined float %#4
%#5 = sqrt float %#4
assume_welldefined float %#5
%#6 = sqrt float %#5
%#7 = fadd float %#6, 0.000000
ret float %#7
}
Transformation seems to be correct! (syntactically equal)
-- 127. InstSimplifyPass
----------------------------------------
declare float @sqrtf(float)
define float @PR22688(float %x) {
#0:
assume_welldefined float %x
%#1 = sqrt float %x
assume_welldefined float %#1
%#2 = sqrt float %#1
assume_welldefined float %#2
%#3 = sqrt float %#2
assume_welldefined float %#3
%#4 = sqrt float %#3
assume_welldefined float %#4
%#5 = sqrt float %#4
assume_welldefined float %#5
%#6 = sqrt float %#5
%#7 = fadd float %#6, 0.000000
ret float %#7
}
Transformation seems to be correct! (syntactically equal)
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstSimplifyPass
----------------------------------------
define float @fabs_select_positive_constants(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 1.000000, float 2.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 131. InstSimplifyPass
----------------------------------------
define float @fabs_select_positive_constants(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 1.000000, float 2.000000
%fabs = fabs float %select
ret float %fabs
}
=>
define float @fabs_select_positive_constants(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 1.000000, float 2.000000
ret float %select
}
Transformation seems to be correct!
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_positive_constants_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 135. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_positive_constants_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_positive_constants_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
ret <2 x float> %select
}
Transformation seems to be correct!
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstSimplifyPass
----------------------------------------
define float @fabs_select_constant_variable(i32 %c, float %x) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 1.000000, float %x
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 139. InstSimplifyPass
----------------------------------------
define float @fabs_select_constant_variable(i32 %c, float %x) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 1.000000, float %x
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_constant_variable_vector(i32 %c, <2 x float> %x) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> %x
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 143. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_constant_variable_vector(i32 %c, <2 x float> %x) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> %x
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstSimplifyPass
----------------------------------------
define float @fabs_select_neg0_pos0(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float -0.000000, float 0.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 147. InstSimplifyPass
----------------------------------------
define float @fabs_select_neg0_pos0(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float -0.000000, float 0.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_neg0_pos0_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { 0.000000, 0.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 151. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_neg0_pos0_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { 0.000000, 0.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstSimplifyPass
----------------------------------------
define float @fabs_select_neg0_neg1(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float -0.000000, float -1.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 155. InstSimplifyPass
----------------------------------------
define float @fabs_select_neg0_neg1(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float -0.000000, float -1.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_neg0_neg1_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { -1.000000, -1.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 159. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_neg0_neg1_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { -1.000000, -1.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
-- 162. InstSimplifyPass
----------------------------------------
define float @fabs_select_nan_nan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0x7fc00000, float 0x7fc00008
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 163. InstSimplifyPass
----------------------------------------
define float @fabs_select_nan_nan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0x7fc00000, float 0x7fc00008
%fabs = fabs float %select
ret float %fabs
}
=>
define float @fabs_select_nan_nan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0x7fc00000, float 0x7fc00008
ret float %select
}
Transformation seems to be correct!
-- 164. PassManager<Function> : Skipping NOP
-- 165. PassManager<Function> : Skipping NOP
-- 166. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_nan_nan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0x7fc00000, 0x7fc00000 }, <2 x float> { 0x7fc00008, 0x7fc00008 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 167. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_nan_nan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0x7fc00000, 0x7fc00000 }, <2 x float> { 0x7fc00008, 0x7fc00008 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_nan_nan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0x7fc00000, 0x7fc00000 }, <2 x float> { 0x7fc00008, 0x7fc00008 }
ret <2 x float> %select
}
Transformation seems to be correct!
-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_nan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float 0x7fc00000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 171. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_nan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float 0x7fc00000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Function> : Skipping NOP
-- 174. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_nan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { 0x7fc00000, 0x7fc00000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 175. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_nan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { 0x7fc00000, 0x7fc00000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_negnan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float 0x7fc00008
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 179. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_negnan(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float 0x7fc00008
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_negnan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { 0x7fc00008, 0x7fc00008 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 183. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_negnan_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { 0x7fc00008, 0x7fc00008 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 184. PassManager<Function> : Skipping NOP
-- 185. PassManager<Function> : Skipping NOP
-- 186. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_negzero(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float -0.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 187. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_negzero(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float -0.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 188. PassManager<Function> : Skipping NOP
-- 189. PassManager<Function> : Skipping NOP
-- 190. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_negzero_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { -0.000000, -0.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 191. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_negzero_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { -0.000000, -0.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_zero(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float 0.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 195. InstSimplifyPass
----------------------------------------
define float @fabs_select_negnan_zero(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, float 0xffc00000, float 0.000000
%fabs = fabs float %select
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 196. PassManager<Function> : Skipping NOP
-- 197. PassManager<Function> : Skipping NOP
-- 198. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_zero_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { 0.000000, 0.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 199. InstSimplifyPass
----------------------------------------
define <2 x float> @fabs_select_negnan_zero_vector(i32 %c) {
#0:
%cmp = icmp eq i32 %c, 0
%select = select i1 %cmp, <2 x float> { 0xffc00000, 0xffc00000 }, <2 x float> { 0.000000, 0.000000 }
%fabs = fabs <2 x float> %select
ret <2 x float> %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 200. PassManager<Function> : Skipping NOP
-- 201. PassManager<Function> : Skipping NOP
-- 202. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt(float %a) {
#0:
%sqrt = sqrt float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 203. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt(float %a) {
#0:
%sqrt = sqrt float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 204. PassManager<Function> : Skipping NOP
-- 205. PassManager<Function> : Skipping NOP
-- 206. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt_nnan(float %a) {
#0:
%sqrt = sqrt nnan float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 207. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt_nnan(float %a) {
#0:
%sqrt = sqrt nnan float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 208. PassManager<Function> : Skipping NOP
-- 209. PassManager<Function> : Skipping NOP
-- 210. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt_nsz(float %a) {
#0:
%sqrt = sqrt nsz float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 211. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt_nsz(float %a) {
#0:
%sqrt = sqrt nsz float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 212. PassManager<Function> : Skipping NOP
-- 213. PassManager<Function> : Skipping NOP
-- 214. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt_nnan_nsz(float %a) {
#0:
%sqrt = sqrt nnan nsz float %a
%fabs = fabs float %sqrt
ret float %fabs
}
Transformation seems to be correct! (syntactically equal)
-- 215. InstSimplifyPass
----------------------------------------
define float @fabs_sqrt_nnan_nsz(float %a) {
#0:
%sqrt = sqrt nnan nsz float %a
%fabs = fabs float %sqrt
ret float %fabs
}
=>
define float @fabs_sqrt_nnan_nsz(float %a) {
#0:
%sqrt = sqrt nnan nsz float %a
ret float %sqrt
}
Transformation doesn't verify! (unsound)
ERROR: Target's return value is more undefined
Example:
float %a = #x00000000 (+0.0)
Source:
float %sqrt = #x00000000 (+0.0)
float %fabs = #x00000000 (+0.0)
Target:
float %sqrt = #x80000000 (-0.0)
Source value: #x00000000 (+0.0)
Target value: #x80000000 (-0.0)
Pass: InstSimplifyPass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-passes=instsimplify' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_emGDz4ul_aAes.bc"
------------------- SMT STATS -------------------
Num queries: 123
Num invalid: 0
Num skips: 0
Num trivial: 122 (49.8%)
Num timeout: 9 (7.3%)
Num errors: 0 (0.0%)
Num SAT: 69 (56.1%)
Num UNSAT: 45 (36.6%)
Alive2: Transform doesn't verify; aborting!
RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/floating-point-arithmetic.ll -passes=instsimplify -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/floating-point-arithmetic.ll + /home/nlopes/alive2/build/opt-alive.sh -passes=instsimplify -S + /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/floating-point-arithmetic.ll FileCheck error: '<stdin>' is empty. FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/floating-point-arithmetic.ll