diff options
Diffstat (limited to 'vendor/modernc.org/libc/ccgo_linux_arm.go')
| -rw-r--r-- | vendor/modernc.org/libc/ccgo_linux_arm.go | 2292 |
1 files changed, 1146 insertions, 1146 deletions
diff --git a/vendor/modernc.org/libc/ccgo_linux_arm.go b/vendor/modernc.org/libc/ccgo_linux_arm.go index 6f519910d..e62167633 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm.go @@ -663,8 +663,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v2 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)<<Int32FromInt32(20))<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) scale2 = *(*float64)(unsafe.Pointer(&v2)) v3 = [2]float64{ - 0: Xcos(tls, y) * exp_x * scale1 * scale2, - 1: Xsin(tls, y) * exp_x * scale1 * scale2, + 0: float64(float64(float64(Xcos(tls, y)*exp_x)*scale1) * scale2), + 1: float64(float64(float64(Xsin(tls, y)*exp_x)*scale1) * scale2), } return *(*complex128)(unsafe.Pointer(&v3)) } @@ -716,8 +716,8 @@ func X__ldexp_cexpf(tls *TLS, z complex64, expt int32) (r complex64) { v2 = Uint32FromInt32((int32(0x7f) + half_expt) << int32(23)) scale2 = *(*float32)(unsafe.Pointer(&v2)) v3 = [2]float32{ - 0: Xcosf(tls, y) * exp_x * scale1 * scale2, - 1: Xsinf(tls, y) * exp_x * scale1 * scale2, + 0: float32(float32(float32(Xcosf(tls, y)*exp_x)*scale1) * scale2), + 1: float32(float32(float32(Xsinf(tls, y)*exp_x)*scale1) * scale2), } return *(*complex64)(unsafe.Pointer(&v3)) } @@ -921,8 +921,8 @@ func Xcasin(tls *TLS, z complex128) (r1 complex128) { x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] v1 = [2]float64{ - 0: float64(1) - (x-y)*(x+y), - 1: -Float64FromFloat64(2) * x * y, + 0: float64(1) - float64((x-y)*(x+y)), + 1: float64(float64(-Float64FromFloat64(2)*x) * y), } w = *(*complex128)(unsafe.Pointer(&v1)) v2 = [2]float64{ @@ -952,7 +952,7 @@ func Xcasinf(tls *TLS, z complex64) (r1 complex64) { y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] v1 = [2]float32{ 0: float32(Float64FromFloat64(1) - float64((x-y)*(x+y))), - 1: float32(-Float64FromFloat64(2) * float64(x) * float64(y)), + 1: float32(float64(float64(-Float64FromFloat64(2)*float64(x)) * float64(y))), } w = *(*complex64)(unsafe.Pointer(&v1)) v2 = [2]float32{ @@ -1042,7 +1042,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int32(t) /* the multiple */ t = float64(i) - t = x - t*_DP1 - t*_DP2 - t*_DP3 + t = x - float64(t*_DP1) - float64(t*_DP2) - float64(t*_DP3) return t } @@ -1057,17 +1057,17 @@ func Xcatan(tls *TLS, z complex128) (r complex128) { _, _, _, _, _, _, _ = a, t, w, x, x2, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] - x2 = x * x - a = float64(1) - x2 - y*y - t = float64(0.5) * Xatan2(tls, float64(2)*x, a) + x2 = float64(x * x) + a = float64(1) - x2 - float64(y*y) + t = float64(float64(0.5) * Xatan2(tls, float64(float64(2)*x), a)) w = Complex128FromFloat64(__redupi(tls, t)) t = y - float64(1) - a = x2 + t*t + a = x2 + float64(t*t) t = y + float64(1) - a = (x2 + t*t) / a + a = (x2 + float64(t*t)) / a v1 = [2]float64{ 0: Float64FromComplex128(w), - 1: float64(0.25) * Xlog(tls, a), + 1: float64(float64(0.25) * Xlog(tls, a)), } w = *(*complex128)(unsafe.Pointer(&v1)) return w @@ -1094,7 +1094,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int32(t) /* the multiple */ t = float32(i) - t = float32(float64(x) - float64(t)*_DP11 - float64(t)*_DP21 - float64(t)*_DP31) + t = float32(float64(x) - float64(float64(t)*_DP11) - float64(float64(t)*_DP21) - float64(float64(t)*_DP31)) return t } @@ -1109,17 +1109,17 @@ func Xcatanf(tls *TLS, z complex64) (r complex64) { _, _, _, _, _, _, _ = a, t, w, x, x2, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] - x2 = x * x - a = Float32FromFloat32(1) - x2 - y*y - t = Float32FromFloat32(0.5) * Xatan2f(tls, Float32FromFloat32(2)*x, a) + x2 = float32(x * x) + a = Float32FromFloat32(1) - x2 - float32(y*y) + t = float32(Float32FromFloat32(0.5) * Xatan2f(tls, float32(Float32FromFloat32(2)*x), a)) w = Complex64FromFloat32(__redupif(tls, t)) t = y - Float32FromFloat32(1) - a = x2 + t*t + a = x2 + float32(t*t) t = y + Float32FromFloat32(1) - a = (x2 + t*t) / a + a = (x2 + float32(t*t)) / a v1 = [2]float32{ 0: Float32FromComplex64(w), - 1: Float32FromFloat32(0.25) * Xlogf(tls, a), + 1: float32(Float32FromFloat32(0.25) * Xlogf(tls, a)), } w = *(*complex64)(unsafe.Pointer(&v1)) return w @@ -1240,24 +1240,24 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if iy|ly == 0 { v1 = [2]float64{ 0: Xcosh(tls, x), - 1: x * y, + 1: float64(x * y), } return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ v2 = [2]float64{ - 0: Xcosh(tls, x) * Xcos(tls, y), - 1: Xsinh(tls, x) * Xsin(tls, y), + 0: float64(Xcosh(tls, x) * Xcos(tls, y)), + 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v2)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ - h = Xexp(tls, Xfabs(tls, x)) * float64(0.5) + h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) v3 = [2]float64{ - 0: h * Xcos(tls, y), - 1: Xcopysign(tls, h, x) * Xsin(tls, y), + 0: float64(h * Xcos(tls, y)), + 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v3)) } else { @@ -1270,15 +1270,15 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float64{ 0: Float64FromComplex128(z), - 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x), + 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } return *(*complex128)(unsafe.Pointer(&v5)) } else { /* x >= 1455: the result always overflows */ - h = _huge * x + h = float64(_huge * x) v6 = [2]float64{ - 0: h * h * Xcos(tls, y), - 1: h * Xsin(tls, y), + 0: float64(float64(h*h) * Xcos(tls, y)), + 1: float64(h * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v6)) } @@ -1296,7 +1296,7 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if ix|lx == 0 && iy >= int32(0x7ff00000) { v7 = [2]float64{ 0: y - y, - 1: Xcopysign(tls, Float64FromInt32(0), x*(y-y)), + 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } return *(*complex128)(unsafe.Pointer(&v7)) } @@ -1309,14 +1309,14 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { v8 = [2]float64{ - 0: x * x, - 1: Xcopysign(tls, Float64FromInt32(0), x) * y, + 0: float64(x * x), + 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } return *(*complex128)(unsafe.Pointer(&v8)) } v9 = [2]float64{ - 0: x * x, - 1: Xcopysign(tls, Float64FromInt32(0), (x+x)*y), + 0: float64(x * x), + 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } return *(*complex128)(unsafe.Pointer(&v9)) } @@ -1331,7 +1331,7 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { v10 = [2]float64{ 0: y - y, - 1: x * (y - y), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v10)) } @@ -1347,14 +1347,14 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { v11 = [2]float64{ - 0: x * x, - 1: x * (y - y), + 0: float64(x * x), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v11)) } v12 = [2]float64{ - 0: x * x * Xcos(tls, y), - 1: x * Xsin(tls, y), + 0: float64(float64(x*x) * Xcos(tls, y)), + 1: float64(x * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v12)) } @@ -1370,8 +1370,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero y. Choice = don't raise (except for signaling NaNs). */ v13 = [2]float64{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float64(float64(x*x) * (y - y)), + 1: float64((x + x) * (y - y)), } return *(*complex128)(unsafe.Pointer(&v13)) } @@ -1397,24 +1397,24 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { if iy == 0 { v1 = [2]float32{ 0: Xcoshf(tls, x), - 1: x * y, + 1: float32(x * y), } return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ v2 = [2]float32{ - 0: Xcoshf(tls, x) * Xcosf(tls, y), - 1: Xsinhf(tls, x) * Xsinf(tls, y), + 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), + 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v2)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ - h = Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5) + h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) v3 = [2]float32{ - 0: h * Xcosf(tls, y), - 1: Xcopysignf(tls, h, x) * Xsinf(tls, y), + 0: float32(h * Xcosf(tls, y)), + 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v3)) } else { @@ -1427,15 +1427,15 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float32{ 0: Float32FromComplex64(z), - 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x), + 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } return *(*complex64)(unsafe.Pointer(&v5)) } else { /* x >= 192.7: the result always overflows */ - h = _huge1 * x + h = float32(_huge1 * x) v6 = [2]float32{ - 0: h * h * Xcosf(tls, y), - 1: h * Xsinf(tls, y), + 0: float32(float32(h*h) * Xcosf(tls, y)), + 1: float32(h * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v6)) } @@ -1444,48 +1444,48 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { if ix == 0 && iy >= int32(0x7f800000) { v7 = [2]float32{ 0: y - y, - 1: Xcopysignf(tls, Float32FromInt32(0), x*(y-y)), + 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } return *(*complex64)(unsafe.Pointer(&v7)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { v8 = [2]float32{ - 0: x * x, - 1: Xcopysignf(tls, Float32FromInt32(0), x) * y, + 0: float32(x * x), + 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } return *(*complex64)(unsafe.Pointer(&v8)) } v9 = [2]float32{ - 0: x * x, - 1: Xcopysignf(tls, Float32FromInt32(0), (x+x)*y), + 0: float32(x * x), + 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } return *(*complex64)(unsafe.Pointer(&v9)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { v10 = [2]float32{ 0: y - y, - 1: x * (y - y), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v10)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { v11 = [2]float32{ - 0: x * x, - 1: x * (y - y), + 0: float32(x * x), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v11)) } v12 = [2]float32{ - 0: x * x * Xcosf(tls, y), - 1: x * Xsinf(tls, y), + 0: float32(float32(x*x) * Xcosf(tls, y)), + 1: float32(x * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v12)) } v13 = [2]float32{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float32(float32(x*x) * (y - y)), + 1: float32((x + x) * (y - y)), } return *(*complex64)(unsafe.Pointer(&v13)) } @@ -1586,8 +1586,8 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { */ exp_x = Xexp(tls, x) v6 = [2]float64{ - 0: exp_x * Xcos(tls, y), - 1: exp_x * Xsin(tls, y), + 0: float64(exp_x * Xcos(tls, y)), + 1: float64(exp_x * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v6)) } @@ -1666,8 +1666,8 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { */ exp_x = Xexpf(tls, x) v6 = [2]float32{ - 0: exp_x * Xcosf(tls, y), - 1: exp_x * Xsinf(tls, y), + 0: float32(exp_x * Xcosf(tls, y)), + 1: float32(exp_x * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v6)) } @@ -2003,18 +2003,18 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { } if ix < int32(0x40360000) { /* small x: normal case */ v2 = [2]float64{ - 0: Xsinh(tls, x) * Xcos(tls, y), - 1: Xcosh(tls, x) * Xsin(tls, y), + 0: float64(Xsinh(tls, x) * Xcos(tls, y)), + 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v2)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ - h = Xexp(tls, Xfabs(tls, x)) * float64(0.5) + h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) v3 = [2]float64{ - 0: Xcopysign(tls, h, x) * Xcos(tls, y), - 1: h * Xsin(tls, y), + 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), + 1: float64(h * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v3)) } else { @@ -2026,16 +2026,16 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { } z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float64{ - 0: Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x), + 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } return *(*complex128)(unsafe.Pointer(&v5)) } else { /* x >= 1455: the result always overflows */ - h = _huge2 * x + h = float64(_huge2 * x) v6 = [2]float64{ - 0: h * Xcos(tls, y), - 1: h * h * Xsin(tls, y), + 0: float64(h * Xcos(tls, y)), + 1: float64(float64(h*h) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v6)) } @@ -2052,7 +2052,7 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix|lx == 0 && iy >= int32(0x7ff00000) { v7 = [2]float64{ - 0: Xcopysign(tls, Float64FromInt32(0), x*(y-y)), + 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } return *(*complex128)(unsafe.Pointer(&v7)) @@ -2087,7 +2087,7 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { v10 = [2]float64{ 0: y - y, - 1: x * (y - y), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v10)) } @@ -2105,14 +2105,14 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { v11 = [2]float64{ - 0: x * x, - 1: x * (y - y), + 0: float64(x * x), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v11)) } v12 = [2]float64{ - 0: x * Xcos(tls, y), - 1: float64(X__builtin_inff(tls)) * Xsin(tls, y), + 0: float64(x * Xcos(tls, y)), + 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v12)) } @@ -2128,8 +2128,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero y. Choice = don't raise (except for signaling NaNs). */ v13 = [2]float64{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float64(float64(x*x) * (y - y)), + 1: float64((x + x) * (y - y)), } return *(*complex128)(unsafe.Pointer(&v13)) } @@ -2161,18 +2161,18 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } if ix < int32(0x41100000) { /* small x: normal case */ v2 = [2]float32{ - 0: Xsinhf(tls, x) * Xcosf(tls, y), - 1: Xcoshf(tls, x) * Xsinf(tls, y), + 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), + 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v2)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ - h = Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5) + h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) v3 = [2]float32{ - 0: Xcopysignf(tls, h, x) * Xcosf(tls, y), - 1: h * Xsinf(tls, y), + 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), + 1: float32(h * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v3)) } else { @@ -2184,16 +2184,16 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float32{ - 0: Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x), + 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } return *(*complex64)(unsafe.Pointer(&v5)) } else { /* x >= 192.7: the result always overflows */ - h = _huge3 * x + h = float32(_huge3 * x) v6 = [2]float32{ - 0: h * Xcosf(tls, y), - 1: h * h * Xsinf(tls, y), + 0: float32(h * Xcosf(tls, y)), + 1: float32(float32(h*h) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v6)) } @@ -2201,7 +2201,7 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } if ix == 0 && iy >= int32(0x7f800000) { v7 = [2]float32{ - 0: Xcopysignf(tls, Float32FromInt32(0), x*(y-y)), + 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } return *(*complex64)(unsafe.Pointer(&v7)) @@ -2223,27 +2223,27 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { v10 = [2]float32{ 0: y - y, - 1: x * (y - y), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v10)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { v11 = [2]float32{ - 0: x * x, - 1: x * (y - y), + 0: float32(x * x), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v11)) } v12 = [2]float32{ - 0: x * Xcosf(tls, y), - 1: X__builtin_inff(tls) * Xsinf(tls, y), + 0: float32(x * Xcosf(tls, y)), + 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v12)) } v13 = [2]float32{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float32(float32(x*x) * (y - y)), + 1: float32((x + x) * (y - y)), } return *(*complex64)(unsafe.Pointer(&v13)) } @@ -2372,16 +2372,16 @@ _9: } /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { - t = Xsqrt(tls, (a+Xhypot(tls, a, b))*float64(0.5)) + t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) v14 = [2]float64{ 0: t, - 1: b / (Float64FromInt32(2) * t), + 1: b / float64(Float64FromInt32(2)*t), } result = *(*complex128)(unsafe.Pointer(&v14)) } else { - t = Xsqrt(tls, (-a+Xhypot(tls, a, b))*float64(0.5)) + t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) v15 = [2]float64{ - 0: Xfabs(tls, b) / (Float64FromInt32(2) * t), + 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } result = *(*complex128)(unsafe.Pointer(&v15)) @@ -2488,16 +2488,16 @@ _9: * This is Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float32FromInt32(0) { - t = Xsqrt(tls, (float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5)) + t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) v14 = [2]float32{ 0: float32(t), - 1: float32(float64(b) / (Float64FromFloat64(2) * t)), + 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } return *(*complex64)(unsafe.Pointer(&v14)) } else { - t = Xsqrt(tls, (float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5)) + t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) v15 = [2]float32{ - 0: float32(float64(Xfabsf(tls, b)) / (Float64FromFloat64(2) * t)), + 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } return *(*complex64)(unsafe.Pointer(&v15)) @@ -2601,7 +2601,7 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { if y == Float64FromInt32(0) { v2 = y } else { - v2 = x * y + v2 = float64(x * y) } v1 = [2]float64{ 0: x, @@ -2618,7 +2618,7 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { v5 = y } else { - v5 = Xsin(tls, y) * Xcos(tls, y) + v5 = float64(Xsin(tls, y) * Xcos(tls, y)) } v4 = [2]float64{ 0: x, @@ -2657,18 +2657,18 @@ _9: exp_mx = Xexp(tls, -Xfabs(tls, x)) v12 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), - 1: Float64FromInt32(4) * Xsin(tls, y) * Xcos(tls, y) * exp_mx * exp_mx, + 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } return *(*complex128)(unsafe.Pointer(&v12)) } /* Kahan's algorithm */ t = Xtan(tls, y) - beta = float64(1) + t*t /* = 1 / cos^2(y) */ + beta = float64(1) + float64(t*t) /* = 1 / cos^2(y) */ s = Xsinh(tls, x) - rho = Xsqrt(tls, Float64FromInt32(1)+s*s) /* = cosh(x) */ - denom = Float64FromInt32(1) + beta*s*s + rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ + denom = Float64FromInt32(1) + float64(float64(beta*s)*s) v13 = [2]float64{ - 0: beta * rho * s / denom, + 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } return *(*complex128)(unsafe.Pointer(&v13)) @@ -2699,7 +2699,7 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { if y == Float32FromInt32(0) { v2 = y } else { - v2 = x * y + v2 = float32(x * y) } v1 = [2]float32{ 0: x, @@ -2716,7 +2716,7 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { v5 = y } else { - v5 = Xsinf(tls, y) * Xcosf(tls, y) + v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } v4 = [2]float32{ 0: x, @@ -2744,17 +2744,17 @@ _9: exp_mx = Xexpf(tls, -Xfabsf(tls, x)) v12 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), - 1: Float32FromInt32(4) * Xsinf(tls, y) * Xcosf(tls, y) * exp_mx * exp_mx, + 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } return *(*complex64)(unsafe.Pointer(&v12)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) - rho = Xsqrtf(tls, Float32FromInt32(1)+s*s) - denom = Float32FromInt32(1) + beta*s*s + rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) + denom = Float32FromInt32(1) + float32(float32(beta*s)*s) v13 = [2]float32{ - 0: beta * rho * s / denom, + 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } return *(*complex64)(unsafe.Pointer(&v13)) @@ -7687,7 +7687,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ 0: uint8(1), } - X__syscall3(tls, int32(SYS_sched_getaffinity), Int32FromInt32(0), Int32FromUint32(Uint32FromInt64(128)), int32(bp+16)) + X__syscall3(tls, int32(SYS_sched_getaffinity), int32(Int32FromInt32(0)), Int32FromUint32(Uint32FromInt64(128)), int32(bp+16)) v3 = Int32FromInt32(0) cnt = v3 i = v3 @@ -7740,7 +7740,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { val = int32(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ) + val += int32(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -14140,7 +14140,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -25075,7 +25075,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { var len1 int32 _, _ = de, len1 if (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos >= (*TDIR)(unsafe.Pointer(dir)).Fbuf_end { - len1 = X__syscall3(tls, int32(SYS_getdents64), (*TDIR)(unsafe.Pointer(dir)).Ffd, int32(dir+24), Int32FromUint32(Uint32FromInt64(2048))) + len1 = int32(X__syscall3(tls, int32(SYS_getdents64), (*TDIR)(unsafe.Pointer(dir)).Ffd, int32(dir+24), Int32FromUint32(Uint32FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 @@ -25242,7 +25242,7 @@ func X__reset_tls(tls *TLS) { var mem, p uintptr var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self - self = ___get_tp(tls) + self = uintptr(___get_tp(tls)) n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head @@ -25272,7 +25272,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { } else { X__stack_chk_guard = Tuintptr_t(uintptr(unsafe.Pointer(&X__stack_chk_guard))) * uint32(1103515245) } - (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Fcanary = X__stack_chk_guard + (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } func X__stack_chk_fail(tls *TLS) { @@ -25881,7 +25881,7 @@ func Xstrerror(tls *TLS, e int32) (r uintptr) { trc("tls=%v e=%v, (%v:)", tls, e, origin(2)) defer func() { trc("-> %v", r) }() } - return X__strerror_l(tls, e, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__strerror_l(tls, e, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } func Xstrerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { @@ -26001,9 +26001,9 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_fcntl64), fd, cmd, int32(uintptr(arg)), 0, 0, 0))) } if cmd == int32(F_GETOWN) { - ret = X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_GETOWN_EX), int32(bp)) + ret = int32(X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETOWN_EX)), int32(bp))) if ret == -int32(EINVAL) { - return X__syscall3(tls, int32(SYS_fcntl64), fd, cmd, int32(uintptr(arg))) + return int32(X__syscall3(tls, int32(SYS_fcntl64), fd, cmd, int32(uintptr(arg)))) } if ret != 0 { return X__syscall_ret(tls, Uint32FromInt32(ret)) @@ -26016,23 +26016,23 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { return v1 } if cmd == int32(F_DUPFD_CLOEXEC) { - ret1 = X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_DUPFD_CLOEXEC), Int32FromUint32(arg)) + ret1 = int32(X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_DUPFD_CLOEXEC)), Int32FromUint32(arg))) if ret1 != -int32(EINVAL) { if ret1 >= 0 { - X__syscall3(tls, int32(SYS_fcntl64), ret1, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), ret1, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } return X__syscall_ret(tls, Uint32FromInt32(ret1)) } - ret1 = X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_DUPFD_CLOEXEC), Int32FromInt32(0)) + ret1 = int32(X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_DUPFD_CLOEXEC)), int32(Int32FromInt32(0)))) if ret1 != -int32(EINVAL) { if ret1 >= 0 { X__syscall1(tls, int32(SYS_close), ret1) } return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } - ret1 = X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_DUPFD), Int32FromUint32(arg)) + ret1 = int32(X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_DUPFD)), Int32FromUint32(arg))) if ret1 >= 0 { - X__syscall3(tls, int32(SYS_fcntl64), ret1, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), ret1, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } return X__syscall_ret(tls, Uint32FromInt32(ret1)) } @@ -26066,9 +26066,9 @@ func Xopen(tls *TLS, filename uintptr, flags int32, va uintptr) (r int32) { mode = VaUint32(&ap) _ = ap } - fd = ___syscall_cp(tls, int32(SYS_open), int32(filename), flags|Int32FromInt32(O_LARGEFILE), Int32FromUint32(mode), 0, 0, 0) + fd = int32(___syscall_cp(tls, int32(SYS_open), int32(filename), int32(flags|Int32FromInt32(O_LARGEFILE)), Int32FromUint32(mode), 0, 0, 0)) if fd >= 0 && flags&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } return X__syscall_ret(tls, Uint32FromInt32(fd)) } @@ -26087,7 +26087,7 @@ func Xopenat(tls *TLS, fd int32, filename uintptr, flags int32, va uintptr) (r i mode = VaUint32(&ap) _ = ap } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_openat), fd, int32(filename), flags|Int32FromInt32(O_LARGEFILE), Int32FromUint32(mode), 0, 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_openat), fd, int32(filename), int32(flags|Int32FromInt32(O_LARGEFILE)), Int32FromUint32(mode), 0, 0))) } func Xposix_fadvise(tls *TLS, fd int32, base Toff_t, len1 Toff_t, advice int32) (r int32) { @@ -26098,7 +26098,7 @@ func Xposix_fadvise(tls *TLS, fd int32, base Toff_t, len1 Toff_t, advice int32) /* Some archs, at least arm and powerpc, have the syscall * arguments reordered to avoid needing 7 argument registers * due to 64-bit argument alignment. */ - return -X__syscall6(tls, int32(SYS_fadvise64_64), fd, advice, int32(base), int32(base>>Int32FromInt32(32)), int32(len1), int32(len1>>Int32FromInt32(32))) + return int32(-X__syscall6(tls, int32(SYS_fadvise64_64), fd, advice, int32(base), int32(base>>Int32FromInt32(32)), int32(len1), int32(len1>>Int32FromInt32(32)))) } func Xposix_fallocate(tls *TLS, fd int32, base Toff_t, len1 Toff_t) (r int32) { @@ -26106,7 +26106,7 @@ func Xposix_fallocate(tls *TLS, fd int32, base Toff_t, len1 Toff_t) (r int32) { trc("tls=%v fd=%v base=%v len1=%v, (%v:)", tls, fd, base, len1, origin(2)) defer func() { trc("-> %v", r) }() } - return -X__syscall6(tls, int32(SYS_fallocate), fd, Int32FromInt32(0), int32(base), int32(base>>Int32FromInt32(32)), int32(len1), int32(len1>>Int32FromInt32(32))) + return int32(-X__syscall6(tls, int32(SYS_fallocate), fd, int32(Int32FromInt32(0)), int32(base), int32(base>>Int32FromInt32(32)), int32(len1), int32(len1>>Int32FromInt32(32)))) } const WCONTINUED = 8 @@ -26437,19 +26437,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Handle zero specially to avoid nasty special cases later */ if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { - return float64(sign) * float64(0) + return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) + return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) } if lrp > int64(-emin/int32(2)) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(1.79769313486231570815e+308) * Float64FromFloat64(1.79769313486231570815e+308) + return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(2.22507385850720138309e-308) * Float64FromFloat64(2.22507385850720138309e-308) + return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ if j != 0 { @@ -26473,14 +26473,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) + return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) } if rp < int32(9) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) * float64(_p10s[rp-int32(10)]) + return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ @@ -26634,7 +26634,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, z = v30 (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) } - y = Float64FromFloat64(1e+09)*y + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _28 _28: ; @@ -26660,16 +26660,16 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(0.25) * float64(sign) + frac += float64(float64(0.25) * float64(sign)) } else { if t > uint32(500000000) { - frac += float64(0.75) * float64(sign) + frac += float64(float64(0.75) * float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(0.5) * float64(sign) + frac += float64(float64(0.5) * float64(sign)) } else { - frac += float64(0.75) * float64(sign) + frac += float64(float64(0.75) * float64(sign)) } } } @@ -26811,10 +26811,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { scale /= Float64FromInt32(16) - y += float64(d) * scale + y += float64(float64(d) * scale) } else { if d != 0 && !(gottail != 0) { - y += Float64FromFloat64(0.5) * scale + y += float64(Float64FromFloat64(0.5) * scale) gottail = int32(1) } } @@ -26850,7 +26850,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } else { X__shlim(tls, f, int64(Int32FromInt32(0))) } - return float64(sign) * float64(0) + return float64(float64(sign) * float64(0)) } if !(gotrad != 0) { rp = dc @@ -26879,15 +26879,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } e2 += int64(4)*rp - int64(32) if !(x != 0) { - return float64(sign) * float64(0) + return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(1.79769313486231570815e+308) * Float64FromFloat64(1.79769313486231570815e+308) + return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(2.22507385850720138309e-308) * Float64FromFloat64(2.22507385850720138309e-308) + return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { @@ -26912,7 +26912,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x++ y = Float64FromInt32(0) } - y = bias + float64(sign)*float64(x) + float64(sign)*y + y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y -= bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -27916,7 +27916,7 @@ func Xmsgctl(tls *TLS, q int32, cmd int32, buf uintptr) (r1 int32) { orig = buf buf = bp } - r = X__syscall3(tls, int32(SYS_msgctl), q, cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64), int32(buf)) + r = int32(X__syscall3(tls, int32(SYS_msgctl), q, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(buf))) if r >= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig *(*Tmsqid_ds)(unsafe.Pointer(buf)) = *(*Tmsqid_ds)(unsafe.Pointer(bp)) @@ -28046,7 +28046,7 @@ func Xsemctl(tls *TLS, id int32, num int32, cmd int32, va uintptr) (r1 int32) { orig = *(*uintptr)(unsafe.Pointer(bp)) *(*uintptr)(unsafe.Pointer(bp)) = bp + 8 } - r = X__syscall4(tls, int32(SYS_semctl), id, num, cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64), int32(*(*uintptr)(unsafe.Pointer(bp)))) + r = int32(X__syscall4(tls, int32(SYS_semctl), id, num, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(*(*uintptr)(unsafe.Pointer(bp))))) if r >= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { *(*uintptr)(unsafe.Pointer(bp)) = orig *(*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = *(*Tsemid_ds)(unsafe.Pointer(bp + 8)) @@ -28146,7 +28146,7 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int } else { v3 = uintptr(0) } - r = X__syscall4(tls, int32(SYS_semtimedop_time64), id, int32(buf), Int32FromUint32(n), int32(v3)) + r = int32(X__syscall4(tls, int32(SYS_semtimedop_time64), id, int32(buf), Int32FromUint32(n), int32(v3))) } if Bool(NO_TIME32 != 0) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -28158,7 +28158,7 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int v5 = uint64(0x7fffffff) + (0+Uint64FromInt64(s))>>int32(63) } *(*[2]int32)(unsafe.Pointer(bp + 16)) = [2]int32{ - 0: Int32FromUint64(v5), + 0: int32(Int32FromUint64(v5)), 1: ns, } v4 = bp + 16 @@ -28265,7 +28265,7 @@ func Xshmctl(tls *TLS, id int32, cmd int32, buf uintptr) (r1 int32) { orig = buf buf = bp } - r = X__syscall3(tls, int32(SYS_shmctl), id, cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64), int32(buf)) + r = int32(X__syscall3(tls, int32(SYS_shmctl), id, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(buf))) if r >= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig *(*Tshmid_ds)(unsafe.Pointer(buf)) = *(*Tshmid_ds)(unsafe.Pointer(bp)) @@ -28589,7 +28589,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { if !(i < n) { break } - *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint32)(unsafe.Pointer(bp + 4 + uintptr(i)*4))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint32)(unsafe.Pointer(bp + 4 + uintptr(i)*4)))) goto _2 _2: ; @@ -29435,7 +29435,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { Fstbcnt: int64((*Ttimex)(unsafe.Pointer(utx)).Fstbcnt), Ftai: (*Ttimex)(unsafe.Pointer(utx)).Ftai, } - r = X__syscall2(tls, int32(SYS_clock_adjtime64), clock_id, int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_clock_adjtime64), clock_id, int32(bp))) if r >= 0 { (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex64)(unsafe.Pointer(bp))).Fmodes (*Ttimex)(unsafe.Pointer(utx)).Foffset = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Foffset) @@ -29490,9 +29490,9 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { Ftai: (*Ttimex)(unsafe.Pointer(utx)).Ftai, } if clock_id == CLOCK_REALTIME { - r = X__syscall1(tls, int32(SYS_adjtimex), int32(bp+208)) + r = int32(X__syscall1(tls, int32(SYS_adjtimex), int32(bp+208))) } else { - r = X__syscall2(tls, int32(SYS_clock_adjtime), clock_id, int32(bp+208)) + r = int32(X__syscall2(tls, int32(SYS_clock_adjtime), clock_id, int32(bp+208))) } if r >= 0 { (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fmodes @@ -29599,9 +29599,9 @@ func Xepoll_create1(tls *TLS, flags int32) (r1 int32) { } var r int32 _ = r - r = X__syscall1(tls, int32(SYS_epoll_create1), flags) + r = int32(X__syscall1(tls, int32(SYS_epoll_create1), flags)) if r == -int32(ENOSYS) && !(flags != 0) { - r = X__syscall1(tls, int32(SYS_epoll_create), Int32FromInt32(1)) + r = int32(X__syscall1(tls, int32(SYS_epoll_create), int32(Int32FromInt32(1)))) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -29621,9 +29621,9 @@ func Xepoll_pwait(tls *TLS, fd int32, ev uintptr, cnt int32, to int32, sigs uint } var r int32 _ = r - r = ___syscall_cp(tls, int32(SYS_epoll_pwait), fd, int32(ev), cnt, to, int32(sigs), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + r = int32(___syscall_cp(tls, int32(SYS_epoll_pwait), fd, int32(ev), cnt, to, int32(sigs), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if r == -int32(ENOSYS) && !(sigs != 0) { - r = ___syscall_cp(tls, int32(SYS_epoll_wait), fd, int32(ev), cnt, to, 0, 0) + r = int32(___syscall_cp(tls, int32(SYS_epoll_wait), fd, int32(ev), cnt, to, 0, 0)) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -29649,9 +29649,9 @@ func Xeventfd(tls *TLS, count uint32, flags int32) (r1 int32) { } var r int32 _ = r - r = X__syscall2(tls, int32(SYS_eventfd2), Int32FromUint32(count), flags) + r = int32(X__syscall2(tls, int32(SYS_eventfd2), Int32FromUint32(count), flags)) if r == -int32(ENOSYS) && !(flags != 0) { - r = X__syscall1(tls, int32(SYS_eventfd), Int32FromUint32(count)) + r = int32(X__syscall1(tls, int32(SYS_eventfd), Int32FromUint32(count))) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -29852,7 +29852,7 @@ func Xfanotify_mark(tls *TLS, fanotify_fd int32, flags uint32, mask uint64, dfd trc("tls=%v fanotify_fd=%v flags=%v mask=%v dfd=%v pathname=%v, (%v:)", tls, fanotify_fd, flags, mask, dfd, pathname, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall6(tls, int32(SYS_fanotify_mark), fanotify_fd, Int32FromUint32(flags), Int32FromUint64(mask), Int32FromUint64(mask>>Int32FromInt32(32)), dfd, int32(pathname)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall6(tls, int32(SYS_fanotify_mark), fanotify_fd, Int32FromUint32(flags), int32(Int32FromUint64(mask)), int32(Int32FromUint64(mask>>Int32FromInt32(32))), dfd, int32(pathname)))) } const LOCK_EX = 2 @@ -29941,9 +29941,9 @@ func Xinotify_init1(tls *TLS, flags int32) (r1 int32) { } var r int32 _ = r - r = X__syscall1(tls, int32(SYS_inotify_init1), flags) + r = int32(X__syscall1(tls, int32(SYS_inotify_init1), flags)) if r == -int32(ENOSYS) && !(flags != 0) { - r = X__syscall0(tls, int32(SYS_inotify_init)) + r = int32(X__syscall0(tls, int32(SYS_inotify_init))) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -30290,7 +30290,7 @@ func Xumount(tls *TLS, special uintptr) (r int32) { trc("tls=%v special=%v, (%v:)", tls, special, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_umount2), int32(special), Int32FromInt32(0)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_umount2), int32(special), int32(Int32FromInt32(0))))) } func Xumount2(tls *TLS, special uintptr, flags int32) (r int32) { @@ -30894,7 +30894,7 @@ func Xreadahead(tls *TLS, fd int32, pos Toff_t, len1 Tsize_t) (r Tssize_t) { trc("tls=%v fd=%v pos=%v len1=%v, (%v:)", tls, fd, pos, len1, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_readahead), fd, Int32FromInt32(0), int32(pos), int32(pos>>Int32FromInt32(32)), Int32FromUint32(len1)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_readahead), fd, int32(Int32FromInt32(0)), int32(pos), int32(pos>>Int32FromInt32(32)), Int32FromUint32(len1)))) } const RB_AUTOBOOT = 19088743 @@ -30910,7 +30910,7 @@ func Xreboot(tls *TLS, type1 int32) (r int32) { trc("tls=%v type1=%v, (%v:)", tls, type1, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_reboot), Int32FromUint32(Uint32FromUint32(0xfee1dead)), Int32FromInt32(672274793), type1))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_reboot), Int32FromUint32(Uint32FromUint32(0xfee1dead)), int32(Int32FromInt32(672274793)), type1))) } func Xremap_file_pages(tls *TLS, addr uintptr, size Tsize_t, prot int32, pgoff Tsize_t, flags int32) (r int32) { @@ -30929,7 +30929,7 @@ func Xsbrk(tls *TLS, inc Tintptr_t) (r uintptr) { if inc != 0 { return uintptr(X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(ENOMEM)))) } - return uintptr(X__syscall1(tls, int32(SYS_brk), Int32FromInt32(0))) + return uintptr(X__syscall1(tls, int32(SYS_brk), int32(Int32FromInt32(0)))) } func Xsendfile(tls *TLS, out_fd int32, in_fd int32, ofs uintptr, count Tsize_t) (r Tssize_t) { @@ -31077,17 +31077,17 @@ func Xsignalfd(tls *TLS, fd int32, sigs uintptr, flags int32) (r int32) { } var ret int32 _ = ret - ret = X__syscall4(tls, int32(SYS_signalfd4), fd, int32(sigs), Int32FromInt32(_NSIG)/Int32FromInt32(8), flags) + ret = int32(X__syscall4(tls, int32(SYS_signalfd4), fd, int32(sigs), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), flags)) if ret != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(ret)) } - ret = X__syscall3(tls, int32(SYS_signalfd), fd, int32(sigs), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + ret = int32(X__syscall3(tls, int32(SYS_signalfd), fd, int32(sigs), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if ret >= 0 { if flags&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), ret, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), ret, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if flags&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), ret, Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) + X__syscall3(tls, int32(SYS_fcntl64), ret, int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } } return X__syscall_ret(tls, Uint32FromInt32(ret)) @@ -31111,7 +31111,7 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u var ret int32 var _ /* st at bp+0 */ Tstat _ = ret - ret = X__syscall5(tls, int32(SYS_statx), dirfd, int32(path), flags, Int32FromUint32(mask), int32(stx)) + ret = int32(X__syscall5(tls, int32(SYS_statx), dirfd, int32(path), flags, Int32FromUint32(mask), int32(stx))) if ret != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(ret)) } @@ -31251,7 +31251,7 @@ func Xtimerfd_settime(tls *TLS, fd int32, flags int32, new1 uintptr, old uintptr 2: vs, 3: int64(vns), } - r = X__syscall4(tls, int32(SYS_timerfd_settime64), fd, flags, int32(bp), int32(old)) + r = int32(X__syscall4(tls, int32(SYS_timerfd_settime64), fd, flags, int32(bp), int32(old))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -31265,7 +31265,7 @@ func Xtimerfd_settime(tls *TLS, fd int32, flags int32, new1 uintptr, old uintptr 2: int32(vs), 3: vns, } - r = X__syscall4(tls, int32(SYS_timerfd_settime32), fd, flags, int32(bp+32), int32(bp+48)) + r = int32(X__syscall4(tls, int32(SYS_timerfd_settime32), fd, flags, int32(bp+32), int32(bp+48))) if !(r != 0) && old != 0 { (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[0]) (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(1)] @@ -31288,12 +31288,12 @@ func Xtimerfd_gettime(tls *TLS, fd int32, cur uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint32(8) > uint32(4) { - r = X__syscall2(tls, int32(SYS_timerfd_gettime64), fd, int32(cur)) + r = int32(X__syscall2(tls, int32(SYS_timerfd_gettime64), fd, int32(cur))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } - r = X__syscall2(tls, int32(SYS_timerfd_gettime32), fd, int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_timerfd_gettime32), fd, int32(bp))) if !(r != 0) { (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)] @@ -31414,7 +31414,7 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 v1 = uintptr(0) } dest = v1 - r = X__syscall4(tls, int32(SYS_wait4), pid, int32(status), options, int32(dest)) + r = int32(X__syscall4(tls, int32(SYS_wait4), pid, int32(status), options, int32(dest))) if r > 0 && ru != 0 && Bool(uint32(8) > uint32(4)) { _memcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ @@ -31556,7 +31556,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale + 5*4))) + return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*4))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -32136,7 +32136,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n var _ /* z at bp+4 */ uintptr _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old, old_cats, old_errno, p2, plural, q, r, rem, rule, trans, v10, v11, v12, v14, v15, v17, v19, v20, v23, v3, v5, v6, v8, v9 defer func() { Xrealloc(tls, name, 0) }() - loc = (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale + loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { @@ -98791,7 +98791,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui *(*Tmbstate_t)(unsafe.Pointer(bp + 16)) = Tmbstate_t{} type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) - ploc = ___get_tp(tls) + 88 + ploc = uintptr(___get_tp(tls)) + 88 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { return uint32(0) @@ -99825,7 +99825,7 @@ func X__nl_langinfo(tls *TLS, item Tnl_item) (r uintptr) { trc("tls=%v item=%v, (%v:)", tls, item, origin(2)) defer func() { trc("-> %v", r) }() } - return X__nl_langinfo_l(tls, item, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__nl_langinfo_l(tls, item, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } func Xnl_langinfo(tls *TLS, item Tnl_item) (r uintptr) { @@ -100543,7 +100543,7 @@ func Xstrcoll(tls *TLS, l uintptr, r uintptr) (r1 int32) { trc("tls=%v l=%v r=%v, (%v:)", tls, l, r, origin(2)) defer func() { trc("-> %v", r1) }() } - return X__strcoll_l(tls, l, r, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__strcoll_l(tls, l, r, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } func Xstrcoll_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -100709,7 +100709,7 @@ func Xstrfmon(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, va uintptr) (r Tssize var ret Tssize_t _, _ = ap, ret ap = va - ret = _vstrfmon_l(tls, s, n, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale, fmt, ap) + ret = _vstrfmon_l(tls, s, n, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale, fmt, ap) _ = ap return ret } @@ -100784,7 +100784,7 @@ func Xstrxfrm(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r Tsize_t) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - return X__strxfrm_l(tls, dest, src, n, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__strxfrm_l(tls, dest, src, n, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } // C documentation @@ -100873,7 +100873,7 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { var global, old, v1, v2 Tlocale_t var self Tpthread_t _, _, _, _, _ = global, old, self, v1, v2 - self = ___get_tp(tls) + self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 32 if new1 != 0 { @@ -100916,7 +100916,7 @@ func Xwcscoll(tls *TLS, l uintptr, r uintptr) (r1 int32) { trc("tls=%v l=%v r=%v, (%v:)", tls, l, r, origin(2)) defer func() { trc("-> %v", r1) }() } - return X__wcscoll_l(tls, l, r, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__wcscoll_l(tls, l, r, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } // C documentation @@ -100957,7 +100957,7 @@ func Xwcsxfrm(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r Tsize_t) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - return X__wcsxfrm_l(tls, dest, src, n, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__wcsxfrm_l(tls, dest, src, n, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } // C documentation @@ -101001,12 +101001,12 @@ func X__cos(tls *TLS, x float64, y float64) (r1 float64) { } var hz, r, w, z Tdouble_t _, _, _, _ = hz, r, w, z - z = x * x - w = z * z - r = z*(_C1+z*(_C2+z*_C3)) + w*w*(_C4+z*(_C5+z*_C6)) - hz = float64(0.5) * z + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = Tdouble_t(z*(_C1+float64(z*(_C2+float64(z*_C3))))) + Tdouble_t(Tdouble_t(w*w)*(_C4+float64(z*(_C5+float64(z*_C6))))) + hz = Tdouble_t(float64(0.5) * z) w = float64(1) - hz - return w + (Float64FromFloat64(1) - w - hz + (z*r - x*y)) + return w + (Float64FromFloat64(1) - w - hz + (Tdouble_t(z*r) - Tdouble_t(x*y))) } // C documentation @@ -101026,10 +101026,10 @@ func X__cosdf(tls *TLS, x float64) (r1 float32) { var r, w, z Tdouble_t _, _, _ = r, w, z /* Try to optimize for parallel evaluation as in __tandf.c. */ - z = x * x - w = z * z - r = _C21 + z*_C31 - return float32(float64(1) + z*_C0 + w*_C11 + w*z*r) + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = _C21 + float64(z*_C31) + return float32(float64(1) + float64(z*_C0) + float64(w*_C11) + float64(Tdouble_t(w*z)*r)) } // C documentation @@ -101054,7 +101054,7 @@ func X__expo2(tls *TLS, x float64, sign float64) (r float64) { scale = *(*float64)(unsafe.Pointer(&v1)) /* exp(x - k ln2) * 2**(k-1) */ /* in directed rounding correct sign before rounding or overflow is important */ - return Xexp(tls, x-_kln22) * (sign * scale) * scale + return float64(float64(Xexp(tls, x-_kln22)*float64(sign*scale)) * scale) } // C documentation @@ -101079,7 +101079,7 @@ func X__expo2f(tls *TLS, x float32, sign float32) (r float32) { scale = *(*float32)(unsafe.Pointer(&v1)) /* exp(x - k ln2) * 2**(k-1) */ /* in directed rounding correct sign before rounding or overflow is important */ - return Xexpf(tls, x-_kln23) * (sign * scale) * scale + return float32(float32(Xexpf(tls, x-_kln23)*float32(sign*scale)) * scale) } func X__fpclassify(tls *TLS, x float64) (r int32) { @@ -101280,7 +101280,7 @@ func X__math_xflow(tls *TLS, sign Tuint32_t, y2 float64) (r float64) { v2 = y1 goto _3 _3: - y = v2 * y2 + y = float64(v2 * y2) v4 = y goto _5 _5: @@ -101303,7 +101303,7 @@ func X__math_xflowf(tls *TLS, sign Tuint32_t, y2 float32) (r float32) { v2 = y1 goto _3 _3: - y = v2 * y2 + y = float32(v2 * y2) v4 = y goto _5 _5: @@ -101387,14 +101387,14 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } } else { if !(sign != 0) { - z = x - Float64FromInt32(2)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z - Float64FromInt32(2)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Float64FromInt32(2)*_pio2_1t + z = x - float64(Float64FromInt32(2)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { - z = x + Float64FromInt32(2)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + Float64FromInt32(2)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Float64FromInt32(2)*_pio2_1t + z = x + float64(Float64FromInt32(2)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -101405,14 +101405,14 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { goto medium } if !(sign != 0) { - z = x - Float64FromInt32(3)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z - Float64FromInt32(3)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Float64FromInt32(3)*_pio2_1t + z = x - float64(Float64FromInt32(3)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { - z = x + Float64FromInt32(3)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + Float64FromInt32(3)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Float64FromInt32(3)*_pio2_1t + z = x + float64(Float64FromInt32(3)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -101420,14 +101420,14 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { goto medium } if !(sign != 0) { - z = x - Float64FromInt32(4)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z - Float64FromInt32(4)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Float64FromInt32(4)*_pio2_1t + z = x - float64(Float64FromInt32(4)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { - z = x + Float64FromInt32(4)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + Float64FromInt32(4)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Float64FromInt32(4)*_pio2_1t + z = x + float64(Float64FromInt32(4)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -101439,22 +101439,22 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { medium: ; /* rint(x/(pi/2)) */ - fn = x*_invpio2 + _toint - _toint + fn = Tdouble_t(x*_invpio2) + _toint - _toint n = int32(fn) - r = x - fn*_pio2_1 - w = fn * _pio2_1t /* 1st round, good to 85 bits */ + r = x - float64(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) /* 1st round, good to 85 bits */ /* Matters with directed rounding. */ if r-w < -_pio4 { n-- fn-- - r = x - fn*_pio2_1 - w = fn * _pio2_1t + r = x - float64(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) } else { if r-w > _pio4 { n++ fn++ - r = x - fn*_pio2_1 - w = fn * _pio2_1t + r = x - float64(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) } } *(*float64)(unsafe.Pointer(y)) = r - w @@ -101463,17 +101463,17 @@ medium: ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ t = r - w = fn * _pio2_2 + w = Tdouble_t(fn * _pio2_2) r = t - w - w = fn*_pio2_2t - (t - r - w) + w = Tdouble_t(fn*_pio2_2t) - (t - r - w) *(*float64)(unsafe.Pointer(y)) = r - w *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r - w = fn * _pio2_3 + w = Tdouble_t(fn * _pio2_3) r = t - w - w = fn*_pio2_3t - (t - r - w) + w = Tdouble_t(fn*_pio2_3t) - (t - r - w) *(*float64)(unsafe.Pointer(y)) = r - w } } @@ -101501,7 +101501,7 @@ _1: break } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = (z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07) + z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; @@ -101681,7 +101681,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += *(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j] + fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) goto _4 _4: ; @@ -101705,8 +101705,8 @@ recompute: if !(j > 0) { break } - fw = float64(int32(Float64FromFloat64(5.960464477539063e-08) * z)) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - Float64FromFloat64(1.6777216e+07)*fw) + fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) + (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101715,8 +101715,8 @@ recompute: j-- } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(8) * Xfloor(tls, z*float64(0.125)) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) z -= float64(n) ih = 0 @@ -101809,7 +101809,7 @@ recompute: if !(j <= jx) { break } - fw += *(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j] + fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) goto _10 _10: ; @@ -101836,8 +101836,8 @@ recompute: } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { - fw = float64(int32(Float64FromFloat64(5.960464477539063e-08) * z)) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - Float64FromFloat64(1.6777216e+07)*fw) + fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) + (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz += int32(1) q0 += int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) @@ -101852,7 +101852,7 @@ recompute: if !(i >= 0) { break } - q[i] = fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i]) + q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) fw *= float64(5.960464477539063e-08) goto _11 _11: @@ -101871,7 +101871,7 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += _PIo2[k] * q[i+k] + fw += float64(_PIo2[k] * q[i+k]) goto _13 _13: ; @@ -102062,19 +102062,19 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* 25+53 bit pi is good enough for medium size */ if ix < uint32(0x4dc90fdb) { /* |x| ~< 2^28*(pi/2), medium size */ /* Use a specialized rint() to get fn. */ - fn = float64(x)*_invpio21 + _toint1 - _toint1 + fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - fn*_pio2_11 - fn*_pio2_1t1 + *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { n-- fn-- - *(*float64)(unsafe.Pointer(y)) = float64(x) - fn*_pio2_11 - fn*_pio2_1t1 + *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { n++ fn++ - *(*float64)(unsafe.Pointer(y)) = float64(x) - fn*_pio2_11 - fn*_pio2_1t1 + *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n @@ -102174,14 +102174,14 @@ func X__sin(tls *TLS, x float64, y float64, iy int32) (r1 float64) { } var r, v, w, z Tdouble_t _, _, _, _ = r, v, w, z - z = x * x - w = z * z - r = _S2 + z*(_S3+z*_S4) + z*w*(_S5+z*_S6) - v = z * x + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = _S2 + float64(z*(_S3+float64(z*_S4))) + float64(Tdouble_t(z*w)*(_S5+float64(z*_S6))) + v = Tdouble_t(z * x) if iy == 0 { - return x + v*(_S1+z*r) + return x + float64(v*(_S1+float64(z*r))) } else { - return x - (z*(Float64FromFloat64(0.5)*y-v*r) - y - v*_S1) + return x - (Tdouble_t(z*(float64(Float64FromFloat64(0.5)*y)-float64(v*r))) - y - Tdouble_t(v*_S1)) } return r1 } @@ -102203,11 +102203,11 @@ func X__sindf(tls *TLS, x float64) (r1 float32) { var r, s, w, z Tdouble_t _, _, _, _ = r, s, w, z /* Try to optimize for parallel evaluation as in __tandf.c. */ - z = x * x - w = z * z - r = _S31 + z*_S41 - s = z * x - return float32(x + s*(_S11+z*_S21) + s*w*r) + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = _S31 + float64(z*_S41) + s = Tdouble_t(z * x) + return float32(x + float64(s*(_S11+float64(z*_S21))) + float64(Tdouble_t(s*w)*r)) } var _T = [13]float64{ @@ -102250,21 +102250,21 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { x = _pio42 - x + (_pio4lo - y) y = float64(0) } - z = x * x - w = z * z + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) /* * Break x^5*(T[1]+x^2*T[2]+...) into * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) + * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12])) */ - r = _T[int32(1)] + w*(_T[int32(3)]+w*(_T[int32(5)]+w*(_T[int32(7)]+w*(_T[int32(9)]+w*_T[int32(11)])))) - v = z * (_T[int32(2)] + w*(_T[int32(4)]+w*(_T[int32(6)]+w*(_T[int32(8)]+w*(_T[int32(10)]+w*_T[int32(12)]))))) - s = z * x - r = y + z*(s*(r+v)+y) + s*_T[0] + r = _T[int32(1)] + float64(w*(_T[int32(3)]+float64(w*(_T[int32(5)]+float64(w*(_T[int32(7)]+float64(w*(_T[int32(9)]+float64(w*_T[int32(11)]))))))))) + v = Tdouble_t(z * (_T[int32(2)] + float64(w*(_T[int32(4)]+float64(w*(_T[int32(6)]+float64(w*(_T[int32(8)]+float64(w*(_T[int32(10)]+float64(w*_T[int32(12)]))))))))))) + s = Tdouble_t(z * x) + r = y + float64(z*(Tdouble_t(s*(r+v))+y)) + float64(s*_T[0]) w = x + r if big != 0 { s = float64(int32(1) - int32(2)*odd) - v = s - float64(2)*(x+(r-w*w/(w+s))) + v = s - Tdouble_t(float64(2)*(x+(r-Tdouble_t(w*w)/(w+s)))) if sign != 0 { v1 = -v } else { @@ -102285,7 +102285,7 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { a0 = v3 v4 = *(*Tuint64_t)(unsafe.Pointer(&a0))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) a0 = *(*float64)(unsafe.Pointer(&v4)) - return a0 + a*(Float64FromFloat64(1)+a0*w0+a0*v) + return a0 + float64(a*(Float64FromFloat64(1)+float64(a0*w0)+float64(a0*v))) } // C documentation @@ -102308,7 +102308,7 @@ func X__tandf(tls *TLS, x float64, odd int32) (r1 float32) { var r, s, t, u, w, z Tdouble_t var v1 float64 _, _, _, _, _, _, _ = r, s, t, u, w, z, v1 - z = x * x + z = Tdouble_t(x * x) /* * Split up the polynomial into small independent terms to give * opportunities for parallel evaluation. The chosen splitting is @@ -102323,12 +102323,12 @@ func X__tandf(tls *TLS, x float64, odd int32) (r1 float32) { * and would give results as accurate as Horner's method if the * small terms were added from highest degree down. */ - r = _T1[int32(4)] + z*_T1[int32(5)] - t = _T1[int32(2)] + z*_T1[int32(3)] - w = z * z - s = z * x - u = _T1[0] + z*_T1[int32(1)] - r = x + s*u + s*w*(t+w*r) + r = _T1[int32(4)] + float64(z*_T1[int32(5)]) + t = _T1[int32(2)] + float64(z*_T1[int32(3)]) + w = Tdouble_t(z * z) + s = Tdouble_t(z * x) + u = _T1[0] + float64(z*_T1[int32(1)]) + r = x + float64(s*u) + float64(Tdouble_t(s*w)*(t+Tdouble_t(w*r))) if odd != 0 { v1 = -Float64FromFloat64(1) / r } else { @@ -102353,8 +102353,8 @@ var _qS4 = float64(0.07703815055590194) /* 0x3FB3B8C5, 0xB12E9282 */ func _R(tls *TLS, z float64) (r float64) { var p, q Tdouble_t _, _ = p, q - p = z * (_pS0 + z*(_pS1+z*(_pS2+z*(_pS3+z*(_pS4+z*_pS5))))) - q = float64(1) + z*(_qS1+z*(_qS2+z*(_qS3+z*_qS4))) + p = Tdouble_t(z * (_pS0 + float64(z*(_pS1+float64(z*(_pS2+float64(z*(_pS3+float64(z*(_pS4+float64(z*_pS5))))))))))) + q = float64(1) + float64(z*(_qS1+float64(z*(_qS2+float64(z*(_qS3+float64(z*_qS4))))))) return p / q } @@ -102375,7 +102375,7 @@ func Xacos(tls *TLS, x float64) (r float64) { if ix-uint32(0x3ff00000)|lx == uint32(0) { /* acos(1)=0, acos(-1)=pi */ if hx>>int32(31) != 0 { - return Float64FromInt32(2)*_pio2_hi + Float64FromFloat32(7.52316384526264e-37) + return float64(Float64FromInt32(2)*_pio2_hi) + Float64FromFloat32(7.52316384526264e-37) } return Float64FromInt32(0) } @@ -102386,24 +102386,24 @@ func Xacos(tls *TLS, x float64) (r float64) { if ix <= uint32(0x3c600000) { /* |x| < 2**-57 */ return _pio2_hi + Float64FromFloat32(7.52316384526264e-37) } - return _pio2_hi - (x - (_pio2_lo - x*_R(tls, x*x))) + return _pio2_hi - (x - (_pio2_lo - float64(x*_R(tls, float64(x*x))))) } /* x < -0.5 */ if hx>>int32(31) != 0 { - z = (float64(1) + x) * float64(0.5) + z = float64((float64(1) + x) * float64(0.5)) s = Xsqrt(tls, z) - w = _R(tls, z)*s - _pio2_lo - return Float64FromInt32(2) * (_pio2_hi - (s + w)) + w = float64(_R(tls, z)*s) - _pio2_lo + return float64(Float64FromInt32(2) * (_pio2_hi - (s + w))) } /* x > 0.5 */ - z = (float64(1) - x) * float64(0.5) + z = float64((float64(1) - x) * float64(0.5)) s = Xsqrt(tls, z) df = s v1 = *(*Tuint64_t)(unsafe.Pointer(&df))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) df = *(*float64)(unsafe.Pointer(&v1)) - c = (z - df*df) / (s + df) - w = _R(tls, z)*s + c - return Float64FromInt32(2) * (df + w) + c = (z - float64(df*df)) / (s + df) + w = float64(_R(tls, z)*s) + c + return float64(Float64FromInt32(2) * (df + w)) } var _pio2_hi1 = float32(1.5707962513) /* 0x3fc90fda */ @@ -102416,8 +102416,8 @@ var _qS11 = float32(-Float64FromFloat64(0.7066296339)) func _R1(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = z * (_pS01 + z*(_pS11+z*_pS21)) - q = Float32FromFloat32(1) + z*_qS11 + p = Tfloat_t(z * (_pS01 + float32(z*(_pS11+float32(z*_pS21))))) + q = Float32FromFloat32(1) + float32(z*_qS11) return p / q } @@ -102435,7 +102435,7 @@ func Xacosf(tls *TLS, x float32) (r float32) { if ix >= uint32(0x3f800000) { if ix == uint32(0x3f800000) { if hx>>int32(31) != 0 { - return Float32FromInt32(2)*_pio2_hi1 + Float32FromFloat32(7.52316384526264e-37) + return float32(Float32FromInt32(2)*_pio2_hi1) + Float32FromFloat32(7.52316384526264e-37) } return Float32FromInt32(0) } @@ -102446,24 +102446,24 @@ func Xacosf(tls *TLS, x float32) (r float32) { if ix <= uint32(0x32800000) { /* |x| < 2**-26 */ return _pio2_hi1 + Float32FromFloat32(7.52316384526264e-37) } - return _pio2_hi1 - (x - (_pio2_lo1 - x*_R1(tls, x*x))) + return _pio2_hi1 - (x - (_pio2_lo1 - float32(x*_R1(tls, float32(x*x))))) } /* x < -0.5 */ if hx>>int32(31) != 0 { - z = (Float32FromInt32(1) + x) * Float32FromFloat32(0.5) + z = float32((Float32FromInt32(1) + x) * Float32FromFloat32(0.5)) s = Xsqrtf(tls, z) - w = _R1(tls, z)*s - _pio2_lo1 - return Float32FromInt32(2) * (_pio2_hi1 - (s + w)) + w = float32(_R1(tls, z)*s) - _pio2_lo1 + return float32(Float32FromInt32(2) * (_pio2_hi1 - (s + w))) } /* x > 0.5 */ - z = (Float32FromInt32(1) - x) * Float32FromFloat32(0.5) + z = float32((Float32FromInt32(1) - x) * Float32FromFloat32(0.5)) s = Xsqrtf(tls, z) hx = *(*Tuint32_t)(unsafe.Pointer(&s)) v1 = hx & uint32(0xfffff000) df = *(*float32)(unsafe.Pointer(&v1)) - c = (z - df*df) / (s + df) - w = _R1(tls, z)*s + c - return Float32FromInt32(2) * (df + w) + c = (z - float32(df*df)) / (s + df) + w = float32(_R1(tls, z)*s) + c + return float32(Float32FromInt32(2) * (df + w)) } // C documentation @@ -102497,11 +102497,11 @@ func Xacosh(tls *TLS, x float64) (r float64) { /* x < 1 domain error is handled in the called functions */ if e < Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1)) { /* |x| < 2, up to 2ulp error in [1,1.125] */ - return Xlog1p(tls, x-Float64FromInt32(1)+Xsqrt(tls, (x-Float64FromInt32(1))*(x-Float64FromInt32(1))+Float64FromInt32(2)*(x-Float64FromInt32(1)))) + return Xlog1p(tls, x-Float64FromInt32(1)+Xsqrt(tls, float64((x-Float64FromInt32(1))*(x-Float64FromInt32(1)))+float64(Float64FromInt32(2)*(x-Float64FromInt32(1))))) } if e < Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(26)) { /* |x| < 0x1p26 */ - return Xlog(tls, Float64FromInt32(2)*x-Float64FromInt32(1)/(x+Xsqrt(tls, x*x-Float64FromInt32(1)))) + return Xlog(tls, float64(Float64FromInt32(2)*x)-Float64FromInt32(1)/(x+Xsqrt(tls, float64(x*x)-Float64FromInt32(1)))) } /* |x| >= 0x1p26 or nan */ return Xlog(tls, x) + float64(0.6931471805599453) @@ -102535,11 +102535,11 @@ func Xacoshf(tls *TLS, x float32) (r float32) { if a < Uint32FromInt32(Int32FromInt32(0x3f800000)+Int32FromInt32(1)<<Int32FromInt32(23)) { /* |x| < 2, invalid if x < 1 */ /* up to 2ulp error in [1,1.125] */ - return Xlog1pf(tls, x-Float32FromInt32(1)+Xsqrtf(tls, (x-Float32FromInt32(1))*(x-Float32FromInt32(1))+Float32FromInt32(2)*(x-Float32FromInt32(1)))) + return Xlog1pf(tls, x-Float32FromInt32(1)+Xsqrtf(tls, float32((x-Float32FromInt32(1))*(x-Float32FromInt32(1)))+float32(Float32FromInt32(2)*(x-Float32FromInt32(1))))) } if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(0x3f800000)+Int32FromInt32(12)<<Int32FromInt32(23)) { /* 2 <= x < 0x1p12 */ - return Xlogf(tls, Float32FromInt32(2)*x-Float32FromInt32(1)/(x+Xsqrtf(tls, x*x-Float32FromInt32(1)))) + return Xlogf(tls, float32(Float32FromInt32(2)*x)-Float32FromInt32(1)/(x+Xsqrtf(tls, float32(x*x)-Float32FromInt32(1)))) } /* x >= 0x1p12 or x <= -2 or nan */ return Xlogf(tls, x) + Float32FromFloat32(0.6931471805599453) @@ -102578,8 +102578,8 @@ var _qS41 = float64(0.07703815055590194) /* 0x3FB3B8C5, 0xB12E9282 * func _R2(tls *TLS, z float64) (r float64) { var p, q Tdouble_t _, _ = p, q - p = z * (_pS02 + z*(_pS12+z*(_pS22+z*(_pS31+z*(_pS41+z*_pS51))))) - q = float64(1) + z*(_qS12+z*(_qS21+z*(_qS31+z*_qS41))) + p = Tdouble_t(z * (_pS02 + float64(z*(_pS12+float64(z*(_pS22+float64(z*(_pS31+float64(z*(_pS41+float64(z*_pS51))))))))))) + q = float64(1) + float64(z*(_qS12+float64(z*(_qS21+float64(z*(_qS31+float64(z*_qS41))))))) return p / q } @@ -102599,7 +102599,7 @@ func Xasin(tls *TLS, x float64) (r1 float64) { lx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x))) if ix-uint32(0x3ff00000)|lx == uint32(0) { /* asin(1) = +-pi/2 with inexact */ - return x*_pio2_hi2 + Float64FromFloat32(7.52316384526264e-37) + return float64(x*_pio2_hi2) + Float64FromFloat32(7.52316384526264e-37) } return Float64FromInt32(0) / (x - x) } @@ -102609,21 +102609,21 @@ func Xasin(tls *TLS, x float64) (r1 float64) { if ix < uint32(0x3e500000) && ix >= uint32(0x00100000) { return x } - return x + x*_R2(tls, x*x) + return x + float64(x*_R2(tls, float64(x*x))) } /* 1 > |x| >= 0.5 */ - z = (Float64FromInt32(1) - Xfabs(tls, x)) * float64(0.5) + z = float64((Float64FromInt32(1) - Xfabs(tls, x)) * float64(0.5)) s = Xsqrt(tls, z) r = _R2(tls, z) if ix >= uint32(0x3fef3333) { /* if |x| > 0.975 */ - x = _pio2_hi2 - (Float64FromInt32(2)*(s+s*r) - _pio2_lo2) + x = _pio2_hi2 - (float64(Float64FromInt32(2)*(s+float64(s*r))) - _pio2_lo2) } else { /* f+c = sqrt(z) */ f = s v1 = *(*Tuint64_t)(unsafe.Pointer(&f))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) f = *(*float64)(unsafe.Pointer(&v1)) - c = (z - f*f) / (s + f) - x = float64(0.5)*_pio2_hi2 - (Float64FromInt32(2)*s*r - (_pio2_lo2 - Float64FromInt32(2)*c) - (float64(0.5)*_pio2_hi2 - Float64FromInt32(2)*f)) + c = (z - float64(f*f)) / (s + f) + x = float64(float64(0.5)*_pio2_hi2) - (float64(float64(Float64FromInt32(2)*s)*r) - (_pio2_lo2 - float64(Float64FromInt32(2)*c)) - (float64(float64(0.5)*_pio2_hi2) - float64(Float64FromInt32(2)*f))) } if hx>>int32(31) != 0 { return -x @@ -102642,8 +102642,8 @@ var _qS13 = float32(-Float64FromFloat64(0.7066296339)) func _R3(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = z * (_pS03 + z*(_pS13+z*_pS23)) - q = Float32FromFloat32(1) + z*_qS13 + p = Tfloat_t(z * (_pS03 + float32(z*(_pS13+float32(z*_pS23))))) + q = Float32FromFloat32(1) + float32(z*_qS13) return p / q } @@ -102660,7 +102660,7 @@ func Xasinf(tls *TLS, x float32) (r float32) { ix = hx & uint32(0x7fffffff) if ix >= uint32(0x3f800000) { /* |x| >= 1 */ if ix == uint32(0x3f800000) { /* |x| == 1 */ - return float32(float64(x)*_pio2 + Float64FromFloat32(7.52316384526264e-37)) + return float32(float64(float64(x)*_pio2) + Float64FromFloat32(7.52316384526264e-37)) } /* asin(+-1) = +-pi/2 with inexact */ return Float32FromInt32(0) / (x - x) /* asin(|x|>1) is NaN */ } @@ -102669,12 +102669,12 @@ func Xasinf(tls *TLS, x float32) (r float32) { if ix < uint32(0x39800000) && ix >= uint32(0x00800000) { return x } - return x + x*_R3(tls, x*x) + return x + float32(x*_R3(tls, float32(x*x))) } /* 1 > |x| >= 0.5 */ - z = (Float32FromInt32(1) - Xfabsf(tls, x)) * Float32FromFloat32(0.5) + z = float32((Float32FromInt32(1) - Xfabsf(tls, x)) * Float32FromFloat32(0.5)) s = Xsqrt(tls, float64(z)) - x = float32(_pio2 - Float64FromInt32(2)*(s+s*float64(_R3(tls, z)))) + x = float32(_pio2 - float64(Float64FromInt32(2)*(s+float64(s*float64(_R3(tls, z)))))) if hx>>int32(31) != 0 { return -x } @@ -102721,11 +102721,11 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { } else { if e >= Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1)) { /* |x| >= 2 */ - x3 = Xlog(tls, Float64FromInt32(2)*x3+Float64FromInt32(1)/(Xsqrt(tls, x3*x3+Float64FromInt32(1))+x3)) + x3 = Xlog(tls, float64(Float64FromInt32(2)*x3)+Float64FromInt32(1)/(Xsqrt(tls, float64(x3*x3)+Float64FromInt32(1))+x3)) } else { if e >= Uint32FromInt32(Int32FromInt32(0x3ff)-Int32FromInt32(26)) { /* |x| >= 0x1p-26, up to 1.6ulp error in [0.125,0.5] */ - x3 = Xlog1p(tls, x3+x3*x3/(Xsqrt(tls, x3*x3+Float64FromInt32(1))+Float64FromInt32(1))) + x3 = Xlog1p(tls, x3+float64(x3*x3)/(Xsqrt(tls, float64(x3*x3)+Float64FromInt32(1))+Float64FromInt32(1))) } else { /* |x| < 0x1p-26, raise inexact if x != 0 */ if uint32(8) == uint32(4) { @@ -102734,7 +102734,7 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { if uint32(8) == uint32(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } } @@ -102786,11 +102786,11 @@ func Xasinhf(tls *TLS, x3 float32) (r float32) { } else { if i >= Uint32FromInt32(Int32FromInt32(0x3f800000)+Int32FromInt32(1)<<Int32FromInt32(23)) { /* |x| >= 2 */ - x3 = Xlogf(tls, Float32FromInt32(2)*x3+Float32FromInt32(1)/(Xsqrtf(tls, x3*x3+Float32FromInt32(1))+x3)) + x3 = Xlogf(tls, float32(Float32FromInt32(2)*x3)+Float32FromInt32(1)/(Xsqrtf(tls, float32(x3*x3)+Float32FromInt32(1))+x3)) } else { if i >= Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(12)<<Int32FromInt32(23)) { /* |x| >= 0x1p-12, up to 1.6ulp error in [0.125,0.5] */ - x3 = Xlog1pf(tls, x3+x3*x3/(Xsqrtf(tls, x3*x3+Float32FromInt32(1))+Float32FromInt32(1))) + x3 = Xlog1pf(tls, x3+float32(x3*x3)/(Xsqrtf(tls, float32(x3*x3)+Float32FromInt32(1))+Float32FromInt32(1))) } else { /* |x| < 0x1p-12, raise inexact if x!=0 */ if uint32(4) == uint32(4) { @@ -102917,7 +102917,7 @@ func Xatan(tls *TLS, x3 float64) (r float64) { if ix < uint32(0x3ff30000) { /* |x| < 1.1875 */ if ix < uint32(0x3fe60000) { /* 7/16 <= |x| < 11/16 */ id = 0 - x3 = (float64(2)*x3 - float64(1)) / (float64(2) + x3) + x3 = (float64(float64(2)*x3) - float64(1)) / (float64(2) + x3) } else { /* 11/16 <= |x| < 19/16 */ id = int32(1) x3 = (x3 - float64(1)) / (x3 + float64(1)) @@ -102925,7 +102925,7 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } else { if ix < uint32(0x40038000) { /* |x| < 2.4375 */ id = int32(2) - x3 = (x3 - float64(1.5)) / (float64(1) + float64(1.5)*x3) + x3 = (x3 - float64(1.5)) / (float64(1) + float64(float64(1.5)*x3)) } else { /* 2.4375 <= |x| < 2^66 */ id = int32(3) x3 = -Float64FromFloat64(1) / x3 @@ -102933,15 +102933,15 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } } /* end of argument reduction */ - z = x3 * x3 - w = z * z + z = Tdouble_t(x3 * x3) + w = Tdouble_t(z * z) /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ - s1 = z * (_aT[0] + w*(_aT[int32(2)]+w*(_aT[int32(4)]+w*(_aT[int32(6)]+w*(_aT[int32(8)]+w*_aT[int32(10)]))))) - s2 = w * (_aT[int32(1)] + w*(_aT[int32(3)]+w*(_aT[int32(5)]+w*(_aT[int32(7)]+w*_aT[int32(9)])))) + s1 = Tdouble_t(z * (_aT[0] + float64(w*(_aT[int32(2)]+float64(w*(_aT[int32(4)]+float64(w*(_aT[int32(6)]+float64(w*(_aT[int32(8)]+float64(w*_aT[int32(10)]))))))))))) + s2 = Tdouble_t(w * (_aT[int32(1)] + float64(w*(_aT[int32(3)]+float64(w*(_aT[int32(5)]+float64(w*(_aT[int32(7)]+float64(w*_aT[int32(9)]))))))))) if id < 0 { - return x3 - x3*(s1+s2) + return x3 - float64(x3*(s1+s2)) } - z = _atanhi[id] - (x3*(s1+s2) - _atanlo[id] - x3) + z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { v4 = -z } else { @@ -103028,9 +103028,9 @@ _2: case uint32(1): return -_pi / Float64FromInt32(4) /* atan(-INF,+INF) */ case uint32(2): - return Float64FromInt32(3) * _pi / Float64FromInt32(4) /* atan(+INF,-INF) */ + return float64(Float64FromInt32(3)*_pi) / Float64FromInt32(4) /* atan(+INF,-INF) */ case uint32(3): - return float64(-Int32FromInt32(3)) * _pi / Float64FromInt32(4) /* atan(-INF,-INF) */ + return float64(float64(-Int32FromInt32(3))*_pi) / Float64FromInt32(4) /* atan(-INF,-INF) */ } } else { switch m { @@ -103145,9 +103145,9 @@ _2: case uint32(1): return -_pi1 / Float32FromInt32(4) /* atan(-INF,+INF) */ case uint32(2): - return Float32FromInt32(3) * _pi1 / Float32FromInt32(4) /*atan(+INF,-INF)*/ + return float32(Float32FromInt32(3)*_pi1) / Float32FromInt32(4) /*atan(+INF,-INF)*/ case uint32(3): - return float32(-Int32FromInt32(3)) * _pi1 / Float32FromInt32(4) /*atan(-INF,-INF)*/ + return float32(float32(-Int32FromInt32(3))*_pi1) / Float32FromInt32(4) /*atan(-INF,-INF)*/ } } else { switch m { @@ -103262,7 +103262,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint32(4) == uint32(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint32(4) == uint32(8) { y1 = float64(x3 * x3) @@ -103279,7 +103279,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x3f980000) { /* |x| < 1.1875 */ if ix < uint32(0x3f300000) { /* 7/16 <= |x| < 11/16 */ id = 0 - x3 = (Float32FromFloat32(2)*x3 - Float32FromFloat32(1)) / (Float32FromFloat32(2) + x3) + x3 = (float32(Float32FromFloat32(2)*x3) - Float32FromFloat32(1)) / (Float32FromFloat32(2) + x3) } else { /* 11/16 <= |x| < 19/16 */ id = int32(1) x3 = (x3 - Float32FromFloat32(1)) / (x3 + Float32FromFloat32(1)) @@ -103287,7 +103287,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } else { if ix < uint32(0x401c0000) { /* |x| < 2.4375 */ id = int32(2) - x3 = (x3 - Float32FromFloat32(1.5)) / (Float32FromFloat32(1) + Float32FromFloat32(1.5)*x3) + x3 = (x3 - Float32FromFloat32(1.5)) / (Float32FromFloat32(1) + float32(Float32FromFloat32(1.5)*x3)) } else { /* 2.4375 <= |x| < 2**26 */ id = int32(3) x3 = -Float32FromFloat32(1) / x3 @@ -103295,15 +103295,15 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } } /* end of argument reduction */ - z = x3 * x3 - w = z * z + z = Tfloat_t(x3 * x3) + w = Tfloat_t(z * z) /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ - s1 = z * (_aT1[0] + w*(_aT1[int32(2)]+w*_aT1[int32(4)])) - s2 = w * (_aT1[int32(1)] + w*_aT1[int32(3)]) + s1 = Tfloat_t(z * (_aT1[0] + float32(w*(_aT1[int32(2)]+float32(w*_aT1[int32(4)]))))) + s2 = Tfloat_t(w * (_aT1[int32(1)] + float32(w*_aT1[int32(3)]))) if id < 0 { - return x3 - x3*(s1+s2) + return x3 - float32(x3*(s1+s2)) } - z = _atanhi1[id] - (x3*(s1+s2) - _atanlo1[id] - x3) + z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { v4 = -z } else { @@ -103363,11 +103363,11 @@ func Xatanh(tls *TLS, x3 float64) (r float64) { } } else { /* |x| < 0.5, up to 1.7ulp error */ - y3 = float64(0.5) * Xlog1p(tls, Float64FromInt32(2)*y3+Float64FromInt32(2)*y3*y3/(Float64FromInt32(1)-y3)) + y3 = Tdouble_t(float64(0.5) * Xlog1p(tls, Tdouble_t(Float64FromInt32(2)*y3)+Tdouble_t(Tdouble_t(Float64FromInt32(2)*y3)*y3)/(Float64FromInt32(1)-y3))) } } else { /* avoid overflow */ - y3 = float64(0.5) * Xlog1p(tls, Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))) + y3 = Tdouble_t(float64(0.5) * Xlog1p(tls, float64(Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))))) } if s != 0 { v1 = -y3 @@ -103413,22 +103413,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint32(4) == uint32(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint32(4) == uint32(8) { - y1 = float64(y3 * y3) + y1 = float64(Tfloat_t(y3 * y3)) } else { - y2 = float64(y3 * y3) + y2 = float64(Tfloat_t(y3 * y3)) } } } } else { /* |x| < 0.5, up to 1.7ulp error */ - y3 = Float32FromFloat32(0.5) * Xlog1pf(tls, Float32FromInt32(2)*y3+Float32FromInt32(2)*y3*y3/(Float32FromInt32(1)-y3)) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, Tfloat_t(Float32FromInt32(2)*y3)+Tfloat_t(Tfloat_t(Float32FromInt32(2)*y3)*y3)/(Float32FromInt32(1)-y3))) } } else { /* avoid overflow */ - y3 = Float32FromFloat32(0.5) * Xlog1pf(tls, Float32FromInt32(2)*(y3/(Float32FromInt32(1)-y3))) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float32FromInt32(2)*(y3/(Float32FromInt32(1)-y3))))) } if s != 0 { v1 = -y3 @@ -103512,7 +103512,7 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * division rounds towards minus infinity; this is also efficient. */ if hx < uint32(0x00100000) { /* zero or subnormal? */ - *(*float64)(unsafe.Pointer(bp)) = x * float64(1.8014398509481984e+16) + *(*float64)(unsafe.Pointer(bp)) = float64(x * float64(1.8014398509481984e+16)) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if hx == uint32(0) { return x @@ -103534,8 +103534,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * * Try to optimize for parallel evaluation as in __tanf.c. */ - r = t * t * (t / x) - t = t * (_P0 + r*(_P1+r*_P2) + r*r*r*(_P3+r*_P4)) + r = Tdouble_t(Tdouble_t(t*t) * (t / x)) + t = Tdouble_t(t * (_P0 + float64(r*(_P1+float64(r*_P2))) + float64(Tdouble_t(Tdouble_t(r*r)*r)*(_P3+float64(r*_P4))))) /* * Round t away from zero to 23 bits (sloppily except for ensuring that * the result is larger in magnitude than cbrt(x) but not much more than @@ -103550,11 +103550,11 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = (*(*Tuint64_t)(unsafe.Pointer(bp)) + uint64(0x80000000)) & uint64(0xffffffffc0000000) t = *(*float64)(unsafe.Pointer(bp)) /* one step Newton iteration to 53 bits with error < 0.667 ulps */ - s = t * t /* t*t is exact */ - r = x / s /* error <= 0.5 ulps; |r| < |t| */ - w = t + t /* t+t is exact */ - r = (r - t) / (w + r) /* r-t is exact; w+r ~= 3*t */ - t = t + t*r /* error <= 0.5 + 0.5/3 + epsilon */ + s = Tdouble_t(t * t) /* t*t is exact */ + r = x / s /* error <= 0.5 ulps; |r| < |t| */ + w = t + t /* t+t is exact */ + r = (r - t) / (w + r) /* r-t is exact; w+r ~= 3*t */ + t = t + Tdouble_t(t*r) /* error <= 0.5 + 0.5/3 + epsilon */ return t } @@ -103592,7 +103592,7 @@ func Xcbrtf(tls *TLS, x float32) (r1 float32) { if hx == uint32(0) { return x } /* cbrt(+-0) is itself */ - *(*float32)(unsafe.Pointer(bp)) = x * Float32FromFloat32(1.6777216e+07) + *(*float32)(unsafe.Pointer(bp)) = float32(x * Float32FromFloat32(1.6777216e+07)) hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) hx = hx/uint32(3) + _B21 } else { @@ -103606,14 +103606,14 @@ func Xcbrtf(tls *TLS, x float32) (r1 float32) { * without causing overflow or underflow. */ T = float64(*(*float32)(unsafe.Pointer(bp))) - r = T * T * T - T = T * (float64(x) + float64(x) + r) / (float64(x) + r + r) + r = Tdouble_t(Tdouble_t(T*T) * T) + T = Tdouble_t(T*(float64(x)+float64(x)+r)) / (float64(x) + r + r) /* * Second step Newton iteration to 47 bits. In double precision for * efficiency and accuracy. */ - r = T * T * T - T = T * (float64(x) + float64(x) + r) / (float64(x) + r + r) + r = Tdouble_t(Tdouble_t(T*T) * T) + T = Tdouble_t(T*(float64(x)+float64(x)+r)) / (float64(x) + r + r) /* rounding to 24 bits is perfect in round-to-nearest mode */ return float32(T) } @@ -103879,7 +103879,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { if uint32(8) == uint32(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } return float64(1) @@ -103911,10 +103911,10 @@ const M_PI_23 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _c1pio2 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _c2pio2 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _c3pio2 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _c4pio2 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _c1pio2 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _c2pio2 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _c3pio2 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _c4pio2 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xcosf(tls *TLS, x3 float32) (r float32) { if __ccgo_strace { @@ -104047,19 +104047,19 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { if uint32(8) == uint32(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } return Float64FromInt32(1) } t = Xexpm1(tls, x3) - return Float64FromInt32(1) + t*t/(Float64FromInt32(2)*(Float64FromInt32(1)+t)) + return Float64FromInt32(1) + float64(t*t)/float64(Float64FromInt32(2)*(Float64FromInt32(1)+t)) } /* |x| < log(DBL_MAX) */ if w < uint32(0x40862e42) { t = Xexp(tls, x3) /* note: if x>log(0x1p26) then the 1/t is not needed */ - return float64(0.5) * (t + Float64FromInt32(1)/t) + return float64(float64(0.5) * (t + Float64FromInt32(1)/t)) } /* |x| > log(DBL_MAX) or nan */ /* note: the result is stored to handle overflow */ @@ -104109,12 +104109,12 @@ func Xcoshf(tls *TLS, x3 float32) (r float32) { return Float32FromInt32(1) } t = Xexpm1f(tls, x3) - return Float32FromInt32(1) + t*t/(Float32FromInt32(2)*(Float32FromInt32(1)+t)) + return Float32FromInt32(1) + float32(t*t)/float32(Float32FromInt32(2)*(Float32FromInt32(1)+t)) } /* |x| < log(FLT_MAX) */ if w < uint32(0x42b17217) { t = Xexpf(tls, x3) - return Float32FromFloat32(0.5) * (t + Float32FromInt32(1)/t) + return float32(Float32FromFloat32(0.5) * (t + Float32FromInt32(1)/t)) } /* |x| > log(FLT_MAX) or nan */ t = X__expo2f(tls, x3, Float32FromFloat32(1)) @@ -104209,8 +104209,8 @@ func _erfc1(tls *TLS, x float64) (r float64) { var P, Q, s Tdouble_t _, _, _ = P, Q, s s = Xfabs(tls, x) - Float64FromInt32(1) - P = _pa0 + s*(_pa1+s*(_pa2+s*(_pa3+s*(_pa4+s*(_pa5+s*_pa6))))) - Q = Float64FromInt32(1) + s*(_qa1+s*(_qa2+s*(_qa3+s*(_qa4+s*(_qa5+s*_qa6))))) + P = _pa0 + float64(s*(_pa1+float64(s*(_pa2+float64(s*(_pa3+float64(s*(_pa4+float64(s*(_pa5+float64(s*_pa6))))))))))) + Q = Float64FromInt32(1) + Tdouble_t(s*(_qa1+float64(s*(_qa2+float64(s*(_qa3+float64(s*(_qa4+float64(s*(_qa5+float64(s*_qa6))))))))))) return Float64FromInt32(1) - _erx - P/Q } @@ -104223,18 +104223,18 @@ func _erfc2(tls *TLS, ix Tuint32_t, x float64) (r float64) { return _erfc1(tls, x) } x = Xfabs(tls, x) - s = Float64FromInt32(1) / (x * x) + s = Float64FromInt32(1) / float64(x*x) if ix < uint32(0x4006db6d) { /* |x| < 1/.35 ~ 2.85714 */ - R = _ra0 + s*(_ra1+s*(_ra2+s*(_ra3+s*(_ra4+s*(_ra5+s*(_ra6+s*_ra7)))))) - S = float64(1) + s*(_sa1+s*(_sa2+s*(_sa3+s*(_sa4+s*(_sa5+s*(_sa6+s*(_sa7+s*_sa8))))))) + R = _ra0 + float64(s*(_ra1+float64(s*(_ra2+float64(s*(_ra3+float64(s*(_ra4+float64(s*(_ra5+float64(s*(_ra6+float64(s*_ra7))))))))))))) + S = float64(1) + float64(s*(_sa1+float64(s*(_sa2+float64(s*(_sa3+float64(s*(_sa4+float64(s*(_sa5+float64(s*(_sa6+float64(s*(_sa7+float64(s*_sa8))))))))))))))) } else { /* |x| > 1/.35 */ - R = _rb0 + s*(_rb1+s*(_rb2+s*(_rb3+s*(_rb4+s*(_rb5+s*_rb6))))) - S = float64(1) + s*(_sb1+s*(_sb2+s*(_sb3+s*(_sb4+s*(_sb5+s*(_sb6+s*_sb7)))))) + R = _rb0 + float64(s*(_rb1+float64(s*(_rb2+float64(s*(_rb3+float64(s*(_rb4+float64(s*(_rb5+float64(s*_rb6))))))))))) + S = float64(1) + float64(s*(_sb1+float64(s*(_sb2+float64(s*(_sb3+float64(s*(_sb4+float64(s*(_sb5+float64(s*(_sb6+float64(s*_sb7))))))))))))) } z = x v1 = *(*Tuint64_t)(unsafe.Pointer(&z))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) z = *(*float64)(unsafe.Pointer(&v1)) - return Xexp(tls, -z*z-float64(0.5625)) * Xexp(tls, (z-x)*(z+x)+R/S) / x + return float64(Xexp(tls, float64(-z*z)-float64(0.5625))*Xexp(tls, float64((z-x)*(z+x))+R/S)) / x } func Xerf(tls *TLS, x float64) (r1 float64) { @@ -104256,13 +104256,13 @@ func Xerf(tls *TLS, x float64) (r1 float64) { if ix < uint32(0x3feb0000) { /* |x| < 0.84375 */ if ix < uint32(0x3e300000) { /* |x| < 2**-28 */ /* avoid underflow */ - return float64(0.125) * (Float64FromInt32(8)*x + _efx8*x) + return float64(float64(0.125) * (float64(Float64FromInt32(8)*x) + float64(_efx8*x))) } - z = x * x - r = _pp0 + z*(_pp1+z*(_pp2+z*(_pp3+z*_pp4))) - s = float64(1) + z*(_qq1+z*(_qq2+z*(_qq3+z*(_qq4+z*_qq5)))) + z = float64(x * x) + r = _pp0 + float64(z*(_pp1+float64(z*(_pp2+float64(z*(_pp3+float64(z*_pp4))))))) + s = float64(1) + float64(z*(_qq1+float64(z*(_qq2+float64(z*(_qq3+float64(z*(_qq4+float64(z*_qq5))))))))) y = r / s - return x + x*y + return x + float64(x*y) } if ix < uint32(0x40180000) { /* 0.84375 <= |x| < 6 */ y = Float64FromInt32(1) - _erfc2(tls, ix, x) @@ -104297,14 +104297,14 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { if ix < uint32(0x3c700000) { /* |x| < 2**-56 */ return float64(1) - x } - z = x * x - r = _pp0 + z*(_pp1+z*(_pp2+z*(_pp3+z*_pp4))) - s = float64(1) + z*(_qq1+z*(_qq2+z*(_qq3+z*(_qq4+z*_qq5)))) + z = float64(x * x) + r = _pp0 + float64(z*(_pp1+float64(z*(_pp2+float64(z*(_pp3+float64(z*_pp4))))))) + s = float64(1) + float64(z*(_qq1+float64(z*(_qq2+float64(z*(_qq3+float64(z*(_qq4+float64(z*_qq5))))))))) y = r / s if sign != 0 || ix < uint32(0x3fd00000) { /* x < 1/4 */ - return float64(1) - (x + x*y) + return float64(1) - (x + float64(x*y)) } - return float64(0.5) - (x - float64(0.5) + x*y) + return float64(0.5) - (x - float64(0.5) + float64(x*y)) } if ix < uint32(0x403c0000) { /* 0.84375 <= |x| < 28 */ if sign != 0 { @@ -104317,7 +104317,7 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { if sign != 0 { v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308) + v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } return v2 } @@ -104394,8 +104394,8 @@ func _erfc11(tls *TLS, x float32) (r float32) { var P, Q, s Tfloat_t _, _, _ = P, Q, s s = Xfabsf(tls, x) - Float32FromInt32(1) - P = _pa01 + s*(_pa11+s*(_pa21+s*(_pa31+s*(_pa41+s*(_pa51+s*_pa61))))) - Q = Float32FromInt32(1) + s*(_qa11+s*(_qa21+s*(_qa31+s*(_qa41+s*(_qa51+s*_qa61))))) + P = _pa01 + float32(s*(_pa11+float32(s*(_pa21+float32(s*(_pa31+float32(s*(_pa41+float32(s*(_pa51+float32(s*_pa61))))))))))) + Q = Float32FromInt32(1) + Tfloat_t(s*(_qa11+float32(s*(_qa21+float32(s*(_qa31+float32(s*(_qa41+float32(s*(_qa51+float32(s*_qa61))))))))))) return Float32FromInt32(1) - _erx1 - P/Q } @@ -104408,18 +104408,18 @@ func _erfc21(tls *TLS, ix Tuint32_t, x float32) (r float32) { return _erfc11(tls, x) } x = Xfabsf(tls, x) - s = Float32FromInt32(1) / (x * x) + s = Float32FromInt32(1) / float32(x*x) if ix < uint32(0x4036db6d) { /* |x| < 1/0.35 */ - R = _ra01 + s*(_ra11+s*(_ra21+s*(_ra31+s*(_ra41+s*(_ra51+s*(_ra61+s*_ra71)))))) - S = Float32FromFloat32(1) + s*(_sa11+s*(_sa21+s*(_sa31+s*(_sa41+s*(_sa51+s*(_sa61+s*(_sa71+s*_sa81))))))) + R = _ra01 + float32(s*(_ra11+float32(s*(_ra21+float32(s*(_ra31+float32(s*(_ra41+float32(s*(_ra51+float32(s*(_ra61+float32(s*_ra71))))))))))))) + S = Float32FromFloat32(1) + float32(s*(_sa11+float32(s*(_sa21+float32(s*(_sa31+float32(s*(_sa41+float32(s*(_sa51+float32(s*(_sa61+float32(s*(_sa71+float32(s*_sa81))))))))))))))) } else { /* |x| >= 1/0.35 */ - R = _rb01 + s*(_rb11+s*(_rb21+s*(_rb31+s*(_rb41+s*(_rb51+s*_rb61))))) - S = Float32FromFloat32(1) + s*(_sb11+s*(_sb21+s*(_sb31+s*(_sb41+s*(_sb51+s*(_sb61+s*_sb71)))))) + R = _rb01 + float32(s*(_rb11+float32(s*(_rb21+float32(s*(_rb31+float32(s*(_rb41+float32(s*(_rb51+float32(s*_rb61))))))))))) + S = Float32FromFloat32(1) + float32(s*(_sb11+float32(s*(_sb21+float32(s*(_sb31+float32(s*(_sb41+float32(s*(_sb51+float32(s*(_sb61+float32(s*_sb71))))))))))))) } ix = *(*Tuint32_t)(unsafe.Pointer(&x)) v1 = ix & uint32(0xffffe000) z = *(*float32)(unsafe.Pointer(&v1)) - return Xexpf(tls, -z*z-Float32FromFloat32(0.5625)) * Xexpf(tls, (z-x)*(z+x)+R/S) / x + return float32(Xexpf(tls, float32(-z*z)-Float32FromFloat32(0.5625))*Xexpf(tls, float32((z-x)*(z+x))+R/S)) / x } func Xerff(tls *TLS, x float32) (r1 float32) { @@ -104441,13 +104441,13 @@ func Xerff(tls *TLS, x float32) (r1 float32) { if ix < uint32(0x3f580000) { /* |x| < 0.84375 */ if ix < uint32(0x31800000) { /* |x| < 2**-28 */ /*avoid underflow */ - return Float32FromFloat32(0.125) * (Float32FromInt32(8)*x + _efx81*x) + return float32(Float32FromFloat32(0.125) * (float32(Float32FromInt32(8)*x) + float32(_efx81*x))) } - z = x * x - r = _pp01 + z*(_pp11+z*(_pp21+z*(_pp31+z*_pp41))) - s = Float32FromInt32(1) + z*(_qq11+z*(_qq21+z*(_qq31+z*(_qq41+z*_qq51)))) + z = float32(x * x) + r = _pp01 + float32(z*(_pp11+float32(z*(_pp21+float32(z*(_pp31+float32(z*_pp41))))))) + s = Float32FromInt32(1) + float32(z*(_qq11+float32(z*(_qq21+float32(z*(_qq31+float32(z*(_qq41+float32(z*_qq51))))))))) y = r / s - return x + x*y + return x + float32(x*y) } if ix < uint32(0x40c00000) { /* |x| < 6 */ y = Float32FromInt32(1) - _erfc21(tls, ix, x) @@ -104482,14 +104482,14 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { if ix < uint32(0x23800000) { /* |x| < 2**-56 */ return Float32FromFloat32(1) - x } - z = x * x - r = _pp01 + z*(_pp11+z*(_pp21+z*(_pp31+z*_pp41))) - s = Float32FromFloat32(1) + z*(_qq11+z*(_qq21+z*(_qq31+z*(_qq41+z*_qq51)))) + z = float32(x * x) + r = _pp01 + float32(z*(_pp11+float32(z*(_pp21+float32(z*(_pp31+float32(z*_pp41))))))) + s = Float32FromFloat32(1) + float32(z*(_qq11+float32(z*(_qq21+float32(z*(_qq31+float32(z*(_qq41+float32(z*_qq51))))))))) y = r / s if sign != 0 || ix < uint32(0x3e800000) { /* x < 1/4 */ - return Float32FromFloat32(1) - (x + x*y) + return Float32FromFloat32(1) - (x + float32(x*y)) } - return Float32FromFloat32(0.5) - (x - Float32FromFloat32(0.5) + x*y) + return Float32FromFloat32(0.5) - (x - Float32FromFloat32(0.5) + float32(x*y)) } if ix < uint32(0x41e00000) { /* |x| < 28 */ if sign != 0 { @@ -104502,7 +104502,7 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { if sign != 0 { v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37) + v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } return v2 } @@ -104546,7 +104546,7 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo /* k > 0, the exponent of scale might have overflowed by <= 460. */ sbits -= Uint64FromUint64(1009) << Int32FromInt32(52) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = float64(5.486124068793689e+303) * (scale + scale*tmp) + y3 = Tdouble_t(float64(5.486124068793689e+303) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -104556,9 +104556,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo /* k < 0, need special care in the subnormal range. */ sbits += Uint64FromUint64(1022) << Int32FromInt32(52) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = scale + scale*tmp + y3 = scale + Tdouble_t(scale*tmp) if y3 < float64(1) { - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = float64(1) + y3 lo = float64(1) - hi + y3 + lo y = hi + lo @@ -104575,9 +104575,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo v5 = y1 goto _6 _6: - y2 = v5 * float64(2.2250738585072014e-308) + y2 = float64(v5 * float64(2.2250738585072014e-308)) } - y3 = float64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(float64(2.2250738585072014e-308) * y3) y = y3 v7 = y goto _8 @@ -104628,7 +104628,7 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { } /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ - z = X__exp_data.Finvln2N * x1 + z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift v2 = y @@ -104638,7 +104638,7 @@ _3: v4 = kd ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) kd -= X__exp_data.Fshift - r = x1 + kd*X__exp_data.Fnegln2hiN + kd*X__exp_data.Fnegln2loN + r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(EXP_TABLE_BITS))) top = ki << (Int32FromInt32(52) - Int32FromInt32(EXP_TABLE_BITS)) @@ -104648,17 +104648,17 @@ _3: sbits = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 112 + uintptr(idx+uint64(1))*8)) + top /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r + r2 = Tdouble_t(r * r) /* Without fma the worst case error is 0.25/N ulp larger. */ /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. */ - tmp = tail + r + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))) + r2*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))) + tmp = tail + r + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))))) + Tdouble_t(Tdouble_t(r2*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))))) if abstop == uint32(0) { return _specialcase(tls, tmp, sbits, ki) } scale = *(*float64)(unsafe.Pointer(&sbits)) /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ - y = scale + scale*tmp + y = scale + Tdouble_t(scale*tmp) v6 = y goto _7 _7: @@ -104698,8 +104698,8 @@ func Xexp10(tls *TLS, x float64) (r float64) { if !(y != 0) { return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] } - y = Xexp2(tls, float64(3.321928094887362)*y) - return y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + y = Xexp2(tls, float64(float64(3.321928094887362)*y)) + return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104774,10 +104774,10 @@ func Xexp10f(tls *TLS, x float32) (r float32) { if !(y != 0) { return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] } - y = Xexp2f(tls, Float32FromFloat32(3.321928094887362)*y) - return y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) + return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) } - return float32(Xexp2(tls, float64(3.321928094887362)*float64(x))) + return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } var _p101 = [15]float32{ @@ -104839,7 +104839,7 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl /* k > 0, the exponent of scale might have overflowed by 1. */ sbits -= Uint64FromUint64(1) << Int32FromInt32(52) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = Float64FromInt32(2) * (scale + scale*tmp) + y3 = Tdouble_t(Float64FromInt32(2) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -104849,9 +104849,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl /* k < 0, need special care in the subnormal range. */ sbits += Uint64FromUint64(1022) << Int32FromInt32(52) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = scale + scale*tmp + y3 = scale + Tdouble_t(scale*tmp) if y3 < float64(1) { - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = float64(1) + y3 lo = float64(1) - hi + y3 + lo y = hi + lo @@ -104868,9 +104868,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl v5 = y1 goto _6 _6: - y2 = v5 * float64(2.2250738585072014e-308) + y2 = float64(v5 * float64(2.2250738585072014e-308)) } - y3 = float64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(float64(2.2250738585072014e-308) * y3) y = y3 v7 = y goto _8 @@ -104945,17 +104945,17 @@ _5: sbits = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 112 + uintptr(idx+uint64(1))*8)) + top /* exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r + r2 = Tdouble_t(r * r) /* Without fma the worst case error is 0.5/N ulp larger. */ /* Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp. */ - tmp = tail + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72)) + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 1*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 2*8))) + r2*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 3*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 4*8))) + tmp = tail + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72))) + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 2*8))))) + Tdouble_t(Tdouble_t(r2*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 4*8))))) if abstop == uint32(0) { return _specialcase1(tls, tmp, sbits, ki) } scale = *(*float64)(unsafe.Pointer(&sbits)) /* Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ - y = scale + scale*tmp + y = scale + Tdouble_t(scale*tmp) v8 = y goto _9 _9: @@ -105023,11 +105023,11 @@ _3: t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)))*8)) t += ki << (Int32FromInt32(52) - Int32FromInt32(EXP2F_TABLE_BITS)) s = *(*float64)(unsafe.Pointer(&t)) - z = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) - r2 = r * r - y2 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r + Float64FromInt32(1) - y2 = z*r2 + y2 - y2 = y2 * s + z = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) + r2 = Tdouble_t(r * r) + y2 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r) + Float64FromInt32(1) + y2 = Tdouble_t(z*r2) + y2 + y2 = Tdouble_t(y2 * s) y = float32(y2) v5 = y goto _6 @@ -105113,7 +105113,7 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { } } /* x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k. */ - z = X__exp2f_data.Finvln2_scaled * xd + z = Tdouble_t(X__exp2f_data.Finvln2_scaled * xd) /* Round and convert z to int, the result is in [-150*N, 128*N] and ideally ties-to-even rule is used, otherwise the magnitude of r can be bigger which gives larger approximation error. */ @@ -105130,11 +105130,11 @@ _3: t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)))*8)) t += ki << (Int32FromInt32(52) - Int32FromInt32(EXP2F_TABLE_BITS)) s = *(*float64)(unsafe.Pointer(&t)) - z = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 1*8)) - r2 = r * r - y2 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 2*8))*r + Float64FromInt32(1) - y2 = z*r2 + y2 - y2 = y2 * s + z = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 1*8)) + r2 = Tdouble_t(r * r) + y2 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 2*8))*r) + Float64FromInt32(1) + y2 = Tdouble_t(z*r2) + y2 + y2 = Tdouble_t(y2 * s) y = float32(y2) v5 = y goto _6 @@ -105232,10 +105232,10 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { } else { v3 = float64(0.5) } - k = int32(_invln2*x3 + v3) + k = int32(float64(_invln2*x3) + v3) t = float64(k) - hi = x3 - t*_ln2_hi /* t*ln2_hi is exact here */ - lo = t * _ln2_lo + hi = x3 - float64(t*_ln2_hi) /* t*ln2_hi is exact here */ + lo = Tdouble_t(t * _ln2_lo) } x3 = hi - lo c = hi - x3 - lo @@ -105258,42 +105258,42 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { } } /* x is now in primary range */ - hfx = float64(0.5) * x3 - hxs = x3 * hfx - r1 = float64(1) + hxs*(_Q1+hxs*(_Q2+hxs*(_Q3+hxs*(_Q4+hxs*_Q5)))) - t = float64(3) - r1*hfx - e = hxs * ((r1 - t) / (Float64FromFloat64(6) - x3*t)) + hfx = Tdouble_t(float64(0.5) * x3) + hxs = Tdouble_t(x3 * hfx) + r1 = float64(1) + float64(hxs*(_Q1+float64(hxs*(_Q2+float64(hxs*(_Q3+float64(hxs*(_Q4+float64(hxs*_Q5))))))))) + t = float64(3) - float64(r1*hfx) + e = Tdouble_t(hxs * ((r1 - t) / (Float64FromFloat64(6) - float64(x3*t)))) if k == 0 { /* c is 0 */ - return x3 - (x3*e - hxs) + return x3 - (float64(x3*e) - hxs) } - e = x3*(e-c) - c + e = float64(x3*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return float64(0.5)*(x3-e) - float64(0.5) + return float64(float64(0.5)*(x3-e)) - float64(0.5) } if k == int32(1) { if x3 < -Float64FromFloat64(0.25) { - return -Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5))) + return float64(-Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5)))) } - return float64(1) + float64(2)*(x3-e) + return float64(1) + float64(float64(2)*(x3-e)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(Int32FromInt32(0x3ff)+k) << int32(52) /* 2^k */ twopk = *(*float64)(unsafe.Pointer(bp + 8)) if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */ y3 = x3 - e + float64(1) if k == int32(1024) { - y3 = y3 * float64(2) * float64(8.98846567431158e+307) + y3 = Tdouble_t(Tdouble_t(y3*float64(2)) * float64(8.98846567431158e+307)) } else { - y3 = y3 * twopk + y3 = Tdouble_t(y3 * twopk) } return y3 - float64(1) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(Int32FromInt32(0x3ff)-k) << int32(52) /* 2^-k */ if k < int32(20) { - y3 = (x3 - e + (Float64FromInt32(1) - *(*float64)(unsafe.Pointer(bp + 8)))) * twopk + y3 = Tdouble_t((x3 - e + (Float64FromInt32(1) - *(*float64)(unsafe.Pointer(bp + 8)))) * twopk) } else { - y3 = (x3 - (e + *(*float64)(unsafe.Pointer(bp + 8))) + Float64FromInt32(1)) * twopk + y3 = Tdouble_t((x3 - (e + *(*float64)(unsafe.Pointer(bp + 8))) + Float64FromInt32(1)) * twopk) } return y3 } @@ -105367,10 +105367,10 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { } else { v1 = Float32FromFloat32(0.5) } - k = int32(_invln21*x3 + v1) + k = int32(float32(_invln21*x3) + v1) t = float32(k) - hi = x3 - t*_ln2_hi1 /* t*ln2_hi is exact here */ - lo = t * _ln2_lo1 + hi = x3 - float32(t*_ln2_hi1) /* t*ln2_hi is exact here */ + lo = Tfloat_t(t * _ln2_lo1) } x3 = hi - lo c = hi - x3 - lo @@ -105378,7 +105378,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint32(4) == uint32(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint32(4) == uint32(8) { y1 = float64(x3 * x3) @@ -105393,42 +105393,42 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { } } /* x is now in primary range */ - hfx = Float32FromFloat32(0.5) * x3 - hxs = x3 * hfx - r1 = Float32FromFloat32(1) + hxs*(_Q11+hxs*_Q21) - t = Float32FromFloat32(3) - r1*hfx - e = hxs * ((r1 - t) / (Float32FromFloat32(6) - x3*t)) + hfx = Tfloat_t(Float32FromFloat32(0.5) * x3) + hxs = Tfloat_t(x3 * hfx) + r1 = Float32FromFloat32(1) + float32(hxs*(_Q11+float32(hxs*_Q21))) + t = Float32FromFloat32(3) - float32(r1*hfx) + e = Tfloat_t(hxs * ((r1 - t) / (Float32FromFloat32(6) - float32(x3*t)))) if k == 0 { /* c is 0 */ - return x3 - (x3*e - hxs) + return x3 - (float32(x3*e) - hxs) } - e = x3*(e-c) - c + e = float32(x3*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return Float32FromFloat32(0.5)*(x3-e) - Float32FromFloat32(0.5) + return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) } if k == int32(1) { if x3 < -Float32FromFloat32(0.25) { - return -Float32FromFloat32(2) * (e - (x3 + Float32FromFloat32(0.5))) + return float32(-Float32FromFloat32(2) * (e - (x3 + Float32FromFloat32(0.5)))) } - return Float32FromFloat32(1) + Float32FromFloat32(2)*(x3-e) + return Float32FromFloat32(1) + float32(Float32FromFloat32(2)*(x3-e)) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) + k) << int32(23)) /* 2^k */ twopk = *(*float32)(unsafe.Pointer(bp)) if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */ y3 = x3 - e + Float32FromFloat32(1) if k == int32(128) { - y3 = y3 * Float32FromFloat32(2) * Float32FromFloat32(1.7014118346046923e+38) + y3 = Tfloat_t(Tfloat_t(y3*Float32FromFloat32(2)) * Float32FromFloat32(1.7014118346046923e+38)) } else { - y3 = y3 * twopk + y3 = Tfloat_t(y3 * twopk) } return y3 - Float32FromFloat32(1) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) - k) << int32(23)) /* 2^-k */ if k < int32(23) { - y3 = (x3 - e + (Float32FromInt32(1) - *(*float32)(unsafe.Pointer(bp)))) * twopk + y3 = Tfloat_t((x3 - e + (Float32FromInt32(1) - *(*float32)(unsafe.Pointer(bp)))) * twopk) } else { - y3 = (x3 - (e + *(*float32)(unsafe.Pointer(bp))) + Float32FromInt32(1)) * twopk + y3 = Tfloat_t((x3 - (e + *(*float32)(unsafe.Pointer(bp))) + Float32FromInt32(1)) * twopk) } return y3 } @@ -105783,7 +105783,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { sign = e & int32(0x800) e &= int32(0x7ff) if !(e != 0) { - v1 = x * float64(9.223372036854776e+18) + v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) e = Int32FromUint64(ix >> int32(52) & uint64(0x7ff)) if e != 0 { @@ -105839,11 +105839,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { ny = _normalize(tls, y) nz = _normalize(tls, z) if nx.Fe >= Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) || ny.Fe >= Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) { - return x1*y + z + return float64(x1*y) + z } if nz.Fe >= Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) { if nz.Fe > Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) { /* z==0 */ - return x1*y + z + return float64(x1*y) + z } return z } @@ -105938,7 +105938,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } } else { /* exact +-0 */ - return x1*y + z + return float64(x1*y) + z } } e -= d @@ -105959,8 +105959,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* min normal after rounding, underflow depends on arch behaviour which can be imitated by a double to float conversion */ - fltmin = float32(Float64FromFloat64(1.0842021401737618e-19) * Float64FromFloat32(1.1754943508222875e-38) * r) - return Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin) + fltmin = float32(float64(Float64FromFloat64(1.0842021401737618e-19)*Float64FromFloat32(1.1754943508222875e-38)) * r) + return float64(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin)) } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ @@ -105970,11 +105970,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { i = -i } r = float64(i) - r = Float64FromInt32(2)*r - c /* remove top bit */ + r = float64(Float64FromInt32(2)*r) - c /* remove top bit */ /* raise underflow portably, such that it cannot be optimized away */ - tiny = Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r - r += tiny * tiny * (r - r) + tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) + r += float64(Tdouble_t(tiny*tiny) * (r - r)) } } else { /* only round once when scaled */ @@ -106306,11 +106306,11 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { _2: } if v3 || BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 || ex == int32(0x7ff) { - return x * y / (x * y) + return float64(x*y) / float64(x*y) } if uxi<<int32(1) <= *(*Tuint64_t)(unsafe.Pointer(bp + 16))<<int32(1) { if uxi<<int32(1) == *(*Tuint64_t)(unsafe.Pointer(bp + 16))<<int32(1) { - return Float64FromInt32(0) * x + return float64(Float64FromInt32(0) * x) } return x } @@ -106357,7 +106357,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { if i == uint64(0) { - return Float64FromInt32(0) * x + return float64(Float64FromInt32(0) * x) } uxi = i } @@ -106370,7 +106370,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { if i == uint64(0) { - return Float64FromInt32(0) * x + return float64(Float64FromInt32(0) * x) } uxi = i } @@ -106447,11 +106447,11 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { _2: } if v3 || BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 || ex == int32(0xff) { - return x * y / (x * y) + return float32(x*y) / float32(x*y) } if uxi<<int32(1) <= *(*Tuint32_t)(unsafe.Pointer(bp + 8))<<int32(1) { if uxi<<int32(1) == *(*Tuint32_t)(unsafe.Pointer(bp + 8))<<int32(1) { - return Float32FromInt32(0) * x + return float32(Float32FromInt32(0) * x) } return x } @@ -106498,7 +106498,7 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { if i == uint32(0) { - return Float32FromInt32(0) * x + return float32(Float32FromInt32(0) * x) } uxi = i } @@ -106511,7 +106511,7 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { if i == uint32(0) { - return Float32FromInt32(0) * x + return float32(Float32FromInt32(0) * x) } uxi = i } @@ -106572,7 +106572,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { ee = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if !(ee != 0) { if x != 0 { - x = Xfrexp(tls, x*float64(1.8446744073709552e+19), e) + x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) *(*int32)(unsafe.Pointer(e)) -= int32(64) } else { *(*int32)(unsafe.Pointer(e)) = 0 @@ -106627,9 +106627,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = *(*Tuint32_t)(unsafe.Pointer(p1)) & Uint32FromUint32(0x807fffff) + *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(p1)) & Uint32FromUint32(0x807fffff)) p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = *(*Tuint32_t)(unsafe.Pointer(p2)) | Uint32FromUint32(0x3f000000) + *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(p2)) | Uint32FromUint32(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106646,11 +106646,11 @@ const SPLIT = 1 func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { var xc, xh, xl Tdouble_t _, _, _ = xc, xh, xl - xc = x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1)) + xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = x * x - *(*Tdouble_t)(unsafe.Pointer(lo)) = xh*xh - *(*Tdouble_t)(unsafe.Pointer(hi)) + Float64FromInt32(2)*xh*xl + xl*xl + *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) + *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106759,7 +106759,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16))) + return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106838,7 +106838,7 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { y *= Float32FromFloat32(1.2379400392853803e+27) } } - return z * Xsqrtf(tls, float32(float64(x)*float64(x)+float64(y)*float64(y))) + return float32(z * Xsqrtf(tls, float32(float64(float64(x)*float64(x))+float64(float64(y)*float64(y))))) } func Xhypotl(tls *TLS, x float64, y float64) (r float64) { @@ -107034,8 +107034,8 @@ func _common(tls *TLS, ix Tuint32_t, x float64, y0 int32) (r float64) { /* avoid overflow in 2*x, big ulp error when x>=0x1p1023 */ if ix < uint32(0x7fe00000) { ss = s - c - z = -Xcos(tls, Float64FromInt32(2)*x) - if s*c < Float64FromInt32(0) { + z = -Xcos(tls, float64(Float64FromInt32(2)*x)) + if float64(s*c) < Float64FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -107044,10 +107044,10 @@ func _common(tls *TLS, ix Tuint32_t, x float64, y0 int32) (r float64) { if y0 != 0 { ss = -ss } - cc = _pzero(tls, x)*cc - _qzero(tls, x)*ss + cc = float64(_pzero(tls, x)*cc) - float64(_qzero(tls, x)*ss) } } - return _invsqrtpi * cc / Xsqrt(tls, x) + return float64(_invsqrtpi*cc) / Xsqrt(tls, x) } // C documentation @@ -107075,7 +107075,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { ix &= uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { - return Float64FromInt32(1) / (x * x) + return Float64FromInt32(1) / float64(x*x) } x = Xfabs(tls, x) if ix >= uint32(0x40000000) { /* |x| >= 2 */ @@ -107085,16 +107085,16 @@ func Xj0(tls *TLS, x float64) (r1 float64) { /* 1 - x*x/4 + x*x*R(x^2)/S(x^2) */ if ix >= uint32(0x3f200000) { /* |x| >= 2**-13 */ /* up to 4ulp error close to 2 */ - z = x * x - r = z * (_R02 + z*(_R03+z*(_R04+z*_R05))) - s = Float64FromInt32(1) + z*(_S01+z*(_S02+z*(_S03+z*_S04))) - return (Float64FromInt32(1)+x/Float64FromInt32(2))*(Float64FromInt32(1)-x/Float64FromInt32(2)) + z*(r/s) + z = float64(x * x) + r = float64(z * (_R02 + float64(z*(_R03+float64(z*(_R04+float64(z*_R05))))))) + s = Float64FromInt32(1) + float64(z*(_S01+float64(z*(_S02+float64(z*(_S03+float64(z*_S04))))))) + return float64((Float64FromInt32(1)+x/Float64FromInt32(2))*(Float64FromInt32(1)-x/Float64FromInt32(2))) + float64(z*(r/s)) } /* 1 - x*x/4 */ /* prevent underflow */ /* inexact should be raised when x!=0, this is not done correctly */ if ix >= uint32(0x38000000) { /* |x| >= 2**-127 */ - x = float64(0.25) * x * x + x = float64(float64(float64(0.25)*x) * x) } return Float64FromInt32(1) - x } @@ -107140,12 +107140,12 @@ func Xy0(tls *TLS, x float64) (r float64) { /* U(x^2)/V(x^2) + (2/pi)*j0(x)*log(x) */ if ix >= uint32(0x3e400000) { /* x >= 2**-27 */ /* large ulp error near the first zero, x ~= 0.89 */ - z = x * x - u = _u00 + z*(_u01+z*(_u02+z*(_u03+z*(_u04+z*(_u05+z*_u06))))) - v = float64(1) + z*(_v01+z*(_v02+z*(_v03+z*_v04))) - return u/v + _tpi*(Xj0(tls, x)*Xlog(tls, x)) + z = float64(x * x) + u = _u00 + float64(z*(_u01+float64(z*(_u02+float64(z*(_u03+float64(z*(_u04+float64(z*(_u05+float64(z*_u06))))))))))) + v = float64(1) + float64(z*(_v01+float64(z*(_v02+float64(z*(_v03+float64(z*_v04))))))) + return u/v + float64(_tpi*float64(Xj0(tls, x)*Xlog(tls, x))) } - return _u00 + _tpi*Xlog(tls, x) + return _u00 + float64(_tpi*Xlog(tls, x)) } // C documentation @@ -107246,9 +107246,9 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z**(*float64)(unsafe.Pointer(q + 4*8)))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) return float64(1) + r/s } @@ -107354,9 +107354,9 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z*(*(*float64)(unsafe.Pointer(q + 4*8))+z**(*float64)(unsafe.Pointer(q + 5*8))))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107378,8 +107378,8 @@ func _common1(tls *TLS, ix Tuint32_t, x float32, y0 int32) (r float32) { cc = s + c if ix < uint32(0x7f000000) { ss = s - c - z = -Xcosf(tls, Float32FromInt32(2)*x) - if s*c < Float32FromInt32(0) { + z = -Xcosf(tls, float32(Float32FromInt32(2)*x)) + if float32(s*c) < Float32FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -107388,10 +107388,10 @@ func _common1(tls *TLS, ix Tuint32_t, x float32, y0 int32) (r float32) { if y0 != 0 { ss = -ss } - cc = _pzerof(tls, x)*cc - _qzerof(tls, x)*ss + cc = float32(_pzerof(tls, x)*cc) - float32(_qzerof(tls, x)*ss) } } - return _invsqrtpi1 * cc / Xsqrtf(tls, x) + return float32(_invsqrtpi1*cc) / Xsqrtf(tls, x) } // C documentation @@ -107418,7 +107418,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { ix = *(*Tuint32_t)(unsafe.Pointer(&x)) ix &= uint32(0x7fffffff) if ix >= uint32(0x7f800000) { - return Float32FromInt32(1) / (x * x) + return Float32FromInt32(1) / float32(x*x) } x = Xfabsf(tls, x) if ix >= uint32(0x40000000) { /* |x| >= 2 */ @@ -107427,13 +107427,13 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { } if ix >= uint32(0x3a000000) { /* |x| >= 2**-11 */ /* up to 4ulp error near 2 */ - z = x * x - r = z * (_R021 + z*(_R031+z*(_R041+z*_R051))) - s = Float32FromInt32(1) + z*(_S011+z*(_S021+z*(_S031+z*_S041))) - return (Float32FromInt32(1)+x/Float32FromInt32(2))*(Float32FromInt32(1)-x/Float32FromInt32(2)) + z*(r/s) + z = float32(x * x) + r = float32(z * (_R021 + float32(z*(_R031+float32(z*(_R041+float32(z*_R051))))))) + s = Float32FromInt32(1) + float32(z*(_S011+float32(z*(_S021+float32(z*(_S031+float32(z*_S041))))))) + return float32((Float32FromInt32(1)+x/Float32FromInt32(2))*(Float32FromInt32(1)-x/Float32FromInt32(2))) + float32(z*(r/s)) } if ix >= uint32(0x21800000) { /* |x| >= 2**-60 */ - x = Float32FromFloat32(0.25) * x * x + x = float32(float32(Float32FromFloat32(0.25)*x) * x) } return Float32FromInt32(1) - x } @@ -107474,12 +107474,12 @@ func Xy0f(tls *TLS, x float32) (r float32) { } if ix >= uint32(0x39000000) { /* x >= 2**-13 */ /* large ulp error at x ~= 0.89 */ - z = x * x - u = _u001 + z*(_u011+z*(_u021+z*(_u031+z*(_u041+z*(_u051+z*_u061))))) - v = Float32FromInt32(1) + z*(_v011+z*(_v021+z*(_v031+z*_v041))) - return u/v + _tpi1*(Xj0f(tls, x)*Xlogf(tls, x)) + z = float32(x * x) + u = _u001 + float32(z*(_u011+float32(z*(_u021+float32(z*(_u031+float32(z*(_u041+float32(z*(_u051+float32(z*_u061))))))))))) + v = Float32FromInt32(1) + float32(z*(_v011+float32(z*(_v021+float32(z*(_v031+float32(z*_v041))))))) + return u/v + float32(_tpi1*float32(Xj0f(tls, x)*Xlogf(tls, x))) } - return _u001 + _tpi1*Xlogf(tls, x) + return _u001 + float32(_tpi1*Xlogf(tls, x)) } // C documentation @@ -107579,9 +107579,9 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z**(*float32)(unsafe.Pointer(q + 4*4)))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107687,9 +107687,9 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z*(*(*float32)(unsafe.Pointer(q + 4*4))+z**(*float32)(unsafe.Pointer(q + 5*4))))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107716,8 +107716,8 @@ func _common2(tls *TLS, ix Tuint32_t, x float64, y1 int32, sign int32) (r float6 if ix < uint32(0x7fe00000) { /* avoid overflow in 2*x */ ss = -s - c - z = Xcos(tls, Float64FromInt32(2)*x) - if s*c > Float64FromInt32(0) { + z = Xcos(tls, float64(Float64FromInt32(2)*x)) + if float64(s*c) > Float64FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -107726,13 +107726,13 @@ func _common2(tls *TLS, ix Tuint32_t, x float64, y1 int32, sign int32) (r float6 if y1 != 0 { ss = -ss } - cc = _pone(tls, x)*cc - _qone(tls, x)*ss + cc = float64(_pone(tls, x)*cc) - float64(_qone(tls, x)*ss) } } if sign != 0 { cc = -cc } - return _invsqrtpi2 * cc / Xsqrt(tls, x) + return float64(_invsqrtpi2*cc) / Xsqrt(tls, x) } // C documentation @@ -107762,21 +107762,21 @@ func Xj1(tls *TLS, x float64) (r1 float64) { sign = Int32FromUint32(ix >> int32(31)) ix &= uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { - return Float64FromInt32(1) / (x * x) + return Float64FromInt32(1) / float64(x*x) } if ix >= uint32(0x40000000) { /* |x| >= 2 */ return _common2(tls, ix, Xfabs(tls, x), 0, sign) } if ix >= uint32(0x38000000) { /* |x| >= 2**-127 */ - z = x * x - r = z * (_r00 + z*(_r01+z*(_r02+z*_r03))) - s = Float64FromInt32(1) + z*(_s01+z*(_s02+z*(_s03+z*(_s04+z*_s05)))) + z = float64(x * x) + r = float64(z * (_r00 + float64(z*(_r01+float64(z*(_r02+float64(z*_r03))))))) + s = Float64FromInt32(1) + float64(z*(_s01+float64(z*(_s02+float64(z*(_s03+float64(z*(_s04+float64(z*_s05))))))))) z = r / s } else { /* avoid underflow, raise inexact if x!=0 */ z = x } - return (float64(0.5) + z) * x + return float64((float64(0.5) + z) * x) } var _U0 = [5]float64{ @@ -107822,10 +107822,10 @@ func Xy1(tls *TLS, x float64) (r float64) { if ix < uint32(0x3c900000) { /* x < 2**-54 */ return -_tpi2 / x } - z = x * x - u = _U0[0] + z*(_U0[int32(1)]+z*(_U0[int32(2)]+z*(_U0[int32(3)]+z*_U0[int32(4)]))) - v = Float64FromInt32(1) + z*(_V0[0]+z*(_V0[int32(1)]+z*(_V0[int32(2)]+z*(_V0[int32(3)]+z*_V0[int32(4)])))) - return x*(u/v) + _tpi2*(Xj1(tls, x)*Xlog(tls, x)-Float64FromInt32(1)/x) + z = float64(x * x) + u = _U0[0] + float64(z*(_U0[int32(1)]+float64(z*(_U0[int32(2)]+float64(z*(_U0[int32(3)]+float64(z*_U0[int32(4)]))))))) + v = Float64FromInt32(1) + float64(z*(_V0[0]+float64(z*(_V0[int32(1)]+float64(z*(_V0[int32(2)]+float64(z*(_V0[int32(3)]+float64(z*_V0[int32(4)]))))))))) + return float64(x*(u/v)) + float64(_tpi2*(float64(Xj1(tls, x)*Xlog(tls, x))-Float64FromInt32(1)/x)) } /* For x >= 8, the asymptotic expansions of pone is @@ -107925,9 +107925,9 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z**(*float64)(unsafe.Pointer(q + 4*8)))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) return float64(1) + r/s } @@ -108032,9 +108032,9 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z*(*(*float64)(unsafe.Pointer(q + 4*8))+z**(*float64)(unsafe.Pointer(q + 5*8))))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -108052,8 +108052,8 @@ func _common3(tls *TLS, ix Tuint32_t, x float32, y1 int32, sign int32) (r float3 cc = s - c if ix < uint32(0x7f000000) { ss = -s - c - z = float64(Xcosf(tls, Float32FromInt32(2)*x)) - if s*c > Float64FromInt32(0) { + z = float64(Xcosf(tls, float32(Float32FromInt32(2)*x))) + if float64(s*c) > Float64FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -108062,13 +108062,13 @@ func _common3(tls *TLS, ix Tuint32_t, x float32, y1 int32, sign int32) (r float3 if y1 != 0 { ss = -ss } - cc = float64(_ponef(tls, x))*cc - float64(_qonef(tls, x))*ss + cc = float64(float64(_ponef(tls, x))*cc) - float64(float64(_qonef(tls, x))*ss) } } if sign != 0 { cc = -cc } - return float32(float64(_invsqrtpi3) * cc / float64(Xsqrtf(tls, x))) + return float32(float64(float64(_invsqrtpi3)*cc) / float64(Xsqrtf(tls, x))) } // C documentation @@ -108098,20 +108098,20 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { sign = Int32FromUint32(ix >> int32(31)) ix &= uint32(0x7fffffff) if ix >= uint32(0x7f800000) { - return Float32FromInt32(1) / (x * x) + return Float32FromInt32(1) / float32(x*x) } if ix >= uint32(0x40000000) { /* |x| >= 2 */ return _common3(tls, ix, Xfabsf(tls, x), 0, sign) } if ix >= uint32(0x39000000) { /* |x| >= 2**-13 */ - z = x * x - r = z * (_r001 + z*(_r011+z*(_r021+z*_r031))) - s = Float32FromInt32(1) + z*(_s011+z*(_s021+z*(_s031+z*(_s041+z*_s051)))) + z = float32(x * x) + r = float32(z * (_r001 + float32(z*(_r011+float32(z*(_r021+float32(z*_r031))))))) + s = Float32FromInt32(1) + float32(z*(_s011+float32(z*(_s021+float32(z*(_s031+float32(z*(_s041+float32(z*_s051))))))))) z = Float32FromFloat32(0.5) + r/s } else { z = Float32FromFloat32(0.5) } - return z * x + return float32(z * x) } var _U01 = [5]float32{ @@ -108153,10 +108153,10 @@ func Xy1f(tls *TLS, x float32) (r float32) { if ix < uint32(0x33000000) { /* x < 2**-25 */ return -_tpi3 / x } - z = x * x - u = _U01[0] + z*(_U01[int32(1)]+z*(_U01[int32(2)]+z*(_U01[int32(3)]+z*_U01[int32(4)]))) - v = Float32FromFloat32(1) + z*(_V01[0]+z*(_V01[int32(1)]+z*(_V01[int32(2)]+z*(_V01[int32(3)]+z*_V01[int32(4)])))) - return x*(u/v) + _tpi3*(Xj1f(tls, x)*Xlogf(tls, x)-Float32FromFloat32(1)/x) + z = float32(x * x) + u = _U01[0] + float32(z*(_U01[int32(1)]+float32(z*(_U01[int32(2)]+float32(z*(_U01[int32(3)]+float32(z*_U01[int32(4)]))))))) + v = Float32FromFloat32(1) + float32(z*(_V01[0]+float32(z*(_V01[int32(1)]+float32(z*(_V01[int32(2)]+float32(z*(_V01[int32(3)]+float32(z*_V01[int32(4)]))))))))) + return float32(x*(u/v)) + float32(_tpi3*(float32(Xj1f(tls, x)*Xlogf(tls, x))-Float32FromFloat32(1)/x)) } /* For x >= 8, the asymptotic expansions of pone is @@ -108256,9 +108256,9 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z**(*float32)(unsafe.Pointer(q + 4*4)))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -108363,9 +108363,9 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z*(*(*float32)(unsafe.Pointer(q + 4*4))+z**(*float32)(unsafe.Pointer(q + 5*4))))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -108440,7 +108440,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { temp = Xcos(tls, x) + Xsin(tls, x) break } - b = _invsqrtpi4 * temp / Xsqrt(tls, x) + b = float64(_invsqrtpi4*temp) / Xsqrt(tls, x) } else { a = Xj0(tls, x) b = Xj1(tls, x) @@ -108451,7 +108451,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { } i++ temp = b - b = b*(float64(2)*float64(i)/x) - a /* avoid underflow */ + b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp goto _1 _1: @@ -108465,7 +108465,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if nm1 > int32(32) { /* underflow */ b = float64(0) } else { - temp = x * float64(0.5) + temp = float64(x * float64(0.5)) b = temp a = float64(1) i = int32(2) @@ -108484,16 +108484,16 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { } } else { nf = float64(nm1) + float64(1) - w = Float64FromInt32(2) * nf / x + w = float64(Float64FromInt32(2)*nf) / x h = Float64FromInt32(2) / x z = w + h q0 = w - q1 = w*z - float64(1) + q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { k += int32(1) z += h - tmp = z*q1 - q0 + tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp } @@ -108503,7 +108503,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i >= 0) { break } - t = Float64FromInt32(1) / (Float64FromInt32(2)*(float64(i)+nf)/x - t) + t = Float64FromInt32(1) / (float64(Float64FromInt32(2)*(float64(i)+nf))/x - t) goto _3 _3: ; @@ -108519,7 +108519,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { * then recurrent value may overflow and the result is * likely underflow to zero */ - tmp = nf * Xlog(tls, Xfabs(tls, w)) + tmp = float64(nf * Xlog(tls, Xfabs(tls, w))) if tmp < float64(709.782712893384) { i = nm1 for { @@ -108527,7 +108527,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { break } temp = b - b = b*(float64(2)*float64(i))/x - a + b = float64(b*float64(float64(2)*float64(i)))/x - a a = temp goto _4 _4: @@ -108541,7 +108541,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { break } temp = b - b = b*(float64(2)*float64(i))/x - a + b = float64(b*float64(float64(2)*float64(i)))/x - a a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { @@ -108558,9 +108558,9 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { z = Xj0(tls, x) w = Xj1(tls, x) if Xfabs(tls, z) >= Xfabs(tls, w) { - b = t * z / b + b = float64(t*z) / b } else { - b = t * w / a + b = float64(t*w) / a } } } @@ -108642,7 +108642,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { temp = Xsin(tls, x) - Xcos(tls, x) break } - b = _invsqrtpi4 * temp / Xsqrt(tls, x) + b = float64(_invsqrtpi4*temp) / Xsqrt(tls, x) } else { a = Xy0(tls, x) b = Xy1(tls, x) @@ -108655,7 +108655,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } i++ temp = b - b = float64(2)*float64(i)/x*b - a + b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) a = temp goto _2 @@ -108715,7 +108715,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { } i++ temp = b - b = b*(Float32FromFloat32(2)*float32(i)/x) - a + b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp goto _1 _1: @@ -108728,7 +108728,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if nm1 > int32(8) { /* underflow */ nm1 = int32(8) } - temp = Float32FromFloat32(0.5) * x + temp = float32(Float32FromFloat32(0.5) * x) b = temp a = Float32FromFloat32(1) i = int32(2) @@ -108746,16 +108746,16 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { b = b / a } else { nf = float32(nm1) + Float32FromFloat32(1) - w = Float32FromInt32(2) * nf / x + w = float32(Float32FromInt32(2)*nf) / x h = Float32FromInt32(2) / x z = w + h q0 = w - q1 = w*z - Float32FromFloat32(1) + q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { k += int32(1) z += h - tmp = z*q1 - q0 + tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp } @@ -108765,7 +108765,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i >= 0) { break } - t = Float32FromFloat32(1) / (Float32FromInt32(2)*(float32(i)+nf)/x - t) + t = Float32FromFloat32(1) / (float32(Float32FromInt32(2)*(float32(i)+nf))/x - t) goto _3 _3: ; @@ -108781,7 +108781,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { * then recurrent value may overflow and the result is * likely underflow to zero */ - tmp = nf * Xlogf(tls, Xfabsf(tls, w)) + tmp = float32(nf * Xlogf(tls, Xfabsf(tls, w))) if tmp < Float32FromFloat32(88.721679688) { i = nm1 for { @@ -108789,7 +108789,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { break } temp = b - b = Float32FromFloat32(2)*float32(i)*b/x - a + b = float32(float32(Float32FromFloat32(2)*float32(i))*b)/x - a a = temp goto _4 _4: @@ -108803,7 +108803,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { break } temp = b - b = Float32FromFloat32(2)*float32(i)*b/x - a + b = float32(float32(Float32FromFloat32(2)*float32(i))*b)/x - a a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { @@ -108820,9 +108820,9 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { z = Xj0f(tls, x) w = Xj1f(tls, x) if Xfabsf(tls, z) >= Xfabsf(tls, w) { - b = t * z / b + b = float32(t*z) / b } else { - b = t * w / a + b = float32(t*w) / a } } } @@ -108885,7 +108885,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { } i++ temp = b - b = Float32FromFloat32(2)*float32(i)/x*b - a + b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) a = temp goto _2 @@ -109002,8 +109002,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { var n int32 _ = n /* spurious inexact if odd int */ - x = float64(2) * (x*float64(0.5) - Xfloor(tls, x*float64(0.5))) /* x mod 2.0 */ - n = int32(x * Float64FromFloat64(4)) + x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ + n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) x -= float64(float32(n) * Float32FromFloat32(0.5)) x *= _pi2 @@ -109053,7 +109053,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { - return x * x + return float64(x * x) } if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))<<Int32FromInt32(20)) { /* |x|<2**-70, return -log(|x|) */ if sign != 0 { @@ -109073,7 +109073,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { } else { t = -t } - nadj = Xlog(tls, _pi2/(t*x)) + nadj = Xlog(tls, _pi2/Tdouble_t(t*x)) } /* purge off 1 and 2 */ if (ix == uint32(0x3ff00000) || ix == uint32(0x40000000)) && uint32(*(*Tuint64_t)(unsafe.Pointer(bp))) == uint32(0) { @@ -109111,31 +109111,31 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { } switch i { case 0: - z = y * y - p1 = _a0 + z*(_a2+z*(_a4+z*(_a6+z*(_a8+z*_a10)))) - p2 = z * (_a1 + z*(_a3+z*(_a5+z*(_a7+z*(_a9+z*_a11))))) - p = y*p1 + p2 - r += p - float64(0.5)*y + z = Tdouble_t(y * y) + p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) + p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) + p = Tdouble_t(y*p1) + p2 + r += p - Tdouble_t(float64(0.5)*y) case int32(1): - z = y * y - w = z * y - p1 = _t0 + w*(_t3+w*(_t6+w*(_t9+w*_t12))) /* parallel comp */ - p2 = _t1 + w*(_t4+w*(_t7+w*(_t10+w*_t13))) - p3 = _t2 + w*(_t5+w*(_t8+w*(_t11+w*_t14))) - p = z*p1 - (_tt - w*(p2+y*p3)) + z = Tdouble_t(y * y) + w = Tdouble_t(z * y) + p1 = _t0 + float64(w*(_t3+float64(w*(_t6+float64(w*(_t9+float64(w*_t12))))))) /* parallel comp */ + p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) + p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) + p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) r += _tf + p case int32(2): - p1 = y * (_u0 + y*(_u1+y*(_u2+y*(_u3+y*(_u4+y*_u5))))) - p2 = float64(1) + y*(_v1+y*(_v2+y*(_v3+y*(_v4+y*_v5)))) - r += -Float64FromFloat64(0.5)*y + p1/p2 + p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) + p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) + r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ i = int32(x) y = x - float64(i) - p = y * (_s0 + y*(_s1+y*(_s2+y*(_s3+y*(_s4+y*(_s5+y*_s6)))))) - q = float64(1) + y*(_r1+y*(_r2+y*(_r3+y*(_r4+y*(_r5+y*_r6))))) - r = float64(0.5)*y + p/q + p = Tdouble_t(y * (_s0 + float64(y*(_s1+float64(y*(_s2+float64(y*(_s3+float64(y*(_s4+float64(y*(_s5+float64(y*_s6))))))))))))) + q = float64(1) + float64(y*(_r1+float64(y*(_r2+float64(y*(_r3+float64(y*(_r4+float64(y*(_r5+float64(y*_r6))))))))))) + r = float64(float64(0.5)*y) + p/q z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): @@ -109159,11 +109159,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < uint32(0x43900000) { /* 8.0 <= x < 2**58 */ t = Xlog(tls, x) z = float64(1) / x - y = z * z - w = _w0 + z*(_w1+y*(_w2+y*(_w3+y*(_w4+y*(_w5+y*_w6))))) - r = (x-float64(0.5))*(t-Float64FromFloat64(1)) + w + y = Tdouble_t(z * z) + w = _w0 + float64(z*(_w1+float64(y*(_w2+float64(y*(_w3+float64(y*(_w4+float64(y*(_w5+float64(y*_w6))))))))))) + r = float64((x-float64(0.5))*(t-Float64FromFloat64(1))) + w } else { /* 2**58 <= x <= inf */ - r = x * (Xlog(tls, x) - float64(1)) + r = Tdouble_t(x * (Xlog(tls, x) - float64(1))) } } } @@ -109262,10 +109262,10 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { var y Tdouble_t _, _ = n, y /* spurious inexact if odd int */ - x = Float32FromInt32(2) * (x*Float32FromFloat32(0.5) - Xfloorf(tls, x*Float32FromFloat32(0.5))) /* x mod 2.0 */ - n = int32(x * Float32FromInt32(4)) + x = float32(Float32FromInt32(2) * (float32(x*Float32FromFloat32(0.5)) - Xfloorf(tls, float32(x*Float32FromFloat32(0.5))))) /* x mod 2.0 */ + n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) - y = float64(x - float32(n)*Float32FromFloat32(0.5)) + y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) y *= float64(3.141592653589793) switch n { default: /* case 4: */ @@ -109310,7 +109310,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { - return x * x + return float32(x * x) } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { @@ -109330,7 +109330,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } else { t = -t } - nadj = Xlogf(tls, _pi3/(t*x)) + nadj = Xlogf(tls, _pi3/float32(t*x)) } /* purge off 1 and 2 */ if ix == uint32(0x3f800000) || ix == uint32(0x40000000) { @@ -109368,31 +109368,31 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } switch i { case 0: - z = y * y - p1 = _a01 + z*(_a21+z*(_a41+z*(_a61+z*(_a81+z*_a101)))) - p2 = z * (_a12 + z*(_a31+z*(_a51+z*(_a71+z*(_a91+z*_a111))))) - p = y*p1 + p2 - r += p - Float32FromFloat32(0.5)*y + z = float32(y * y) + p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) + p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) + p = float32(y*p1) + p2 + r += p - float32(Float32FromFloat32(0.5)*y) case int32(1): - z = y * y - w = z * y - p1 = _t01 + w*(_t31+w*(_t61+w*(_t91+w*_t121))) /* parallel comp */ - p2 = _t15 + w*(_t41+w*(_t71+w*(_t101+w*_t131))) - p3 = _t21 + w*(_t51+w*(_t81+w*(_t111+w*_t141))) - p = z*p1 - (_tt1 - w*(p2+y*p3)) + z = float32(y * y) + w = float32(z * y) + p1 = _t01 + float32(w*(_t31+float32(w*(_t61+float32(w*(_t91+float32(w*_t121))))))) /* parallel comp */ + p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) + p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) + p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) r += _tf1 + p case int32(2): - p1 = y * (_u07 + y*(_u11+y*(_u21+y*(_u31+y*(_u41+y*_u51))))) - p2 = Float32FromFloat32(1) + y*(_v11+y*(_v21+y*(_v31+y*(_v41+y*_v51)))) - r += -Float32FromFloat32(0.5)*y + p1/p2 + p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) + p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) + r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ i = int32(x) y = x - float32(i) - p = y * (_s06 + y*(_s11+y*(_s21+y*(_s31+y*(_s41+y*(_s51+y*_s61)))))) - q = Float32FromFloat32(1) + y*(_r11+y*(_r21+y*(_r31+y*(_r41+y*(_r51+y*_r61))))) - r = Float32FromFloat32(0.5)*y + p/q + p = float32(y * (_s06 + float32(y*(_s11+float32(y*(_s21+float32(y*(_s31+float32(y*(_s41+float32(y*(_s51+float32(y*_s61))))))))))))) + q = Float32FromFloat32(1) + float32(y*(_r11+float32(y*(_r21+float32(y*(_r31+float32(y*(_r41+float32(y*(_r51+float32(y*_r61))))))))))) + r = float32(Float32FromFloat32(0.5)*y) + p/q z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): @@ -109416,11 +109416,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { if ix < uint32(0x5c800000) { /* 8.0 <= x < 2**58 */ t = Xlogf(tls, x) z = Float32FromFloat32(1) / x - y = z * z - w = _w01 + z*(_w11+y*(_w21+y*(_w31+y*(_w41+y*(_w51+y*_w61))))) - r = (x-Float32FromFloat32(0.5))*(t-Float32FromFloat32(1)) + w + y = float32(z * z) + w = _w01 + float32(z*(_w11+float32(y*(_w21+float32(y*(_w31+float32(y*(_w41+float32(y*(_w51+float32(y*_w61))))))))))) + r = float32((x-Float32FromFloat32(0.5))*(t-Float32FromFloat32(1))) + w } else { /* 2**58 <= x <= inf */ - r = x * (Xlogf(tls, x) - Float32FromFloat32(1)) + r = float32(x * (Xlogf(tls, x) - Float32FromFloat32(1))) } } } @@ -109572,17 +109572,17 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - r2 = r * r - r3 = r * r2 - y1 = r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8)) + r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8)) + r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8))+r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8))+r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8))+r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8))+r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))) + r2 = Tdouble_t(r * r) + r3 = Tdouble_t(r * r2) + y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ - w = r * float64(1.34217728e+08) + w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = rhi * rhi * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56)) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56)) * rlo * (rhi + r) + lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) y1 += lo y1 += hi y = y1 @@ -109604,7 +109604,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = x1 * float64(4.503599627370496e+15) + v9 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) ix -= Uint64FromUint64(52) << Int32FromInt32(52) } @@ -109629,7 +109629,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { /* log(x) = log1p(z/c-1) + log(c) + k*Ln2. */ /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N + 0x1p-66. */ - r = (z - (*(*struct { + r = Tdouble_t((z - (*(*struct { F__ccgo_align [0]uint32 Fchi float64 Fclo float64 @@ -109637,19 +109637,19 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { F__ccgo_align [0]uint32 Fchi float64 Fclo float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 2192 + uintptr(i)*16))).Fclo) * invc + })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 2192 + uintptr(i)*16))).Fclo) * invc) kd = float64(k) /* hi + lo = r + log(c) + k*Ln2. */ - w = kd*X__log_data.Fln2hi + logc + w = Tdouble_t(kd*X__log_data.Fln2hi) + logc hi = w + r - lo = w - hi + r + kd*X__log_data.Fln2lo + lo = w - hi + r + Tdouble_t(kd*X__log_data.Fln2lo) /* log(x) = lo + (log1p(r) - r) + hi. */ - r2 = r * r /* rounding error: 0x1p-54/N^2. */ + r2 = Tdouble_t(r * r) /* rounding error: 0x1p-54/N^2. */ /* Worst case error if |y| > 0x1p-5: 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma) Worst case error if |y| > 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16)) + r*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8))+r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8)))) + hi + y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v10 = y goto _11 @@ -109699,7 +109699,7 @@ func Xlog10(tls *TLS, x float64) (r float64) { k = 0 if hx < uint32(0x00100000) || hx>>int32(31) != 0 { if *(*Tuint64_t)(unsafe.Pointer(bp))<<int32(1) == uint64(0) { - return float64(-Int32FromInt32(1)) / (x * x) + return float64(-Int32FromInt32(1)) / float64(x*x) } /* log(+-0)=-inf */ if hx>>int32(31) != 0 { return (x - x) / float64(0) @@ -109725,12 +109725,12 @@ func Xlog10(tls *TLS, x float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff) x = *(*float64)(unsafe.Pointer(bp)) f = x - float64(1) - hfsq = float64(0.5) * f * f + hfsq = Tdouble_t(float64(float64(0.5)*f) * f) s = f / (Float64FromFloat64(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg2 + w*(_Lg4+w*_Lg6)) - t2 = z * (_Lg1 + w*(_Lg3+w*(_Lg5+w*_Lg7))) + z = Tdouble_t(s * s) + w = Tdouble_t(z * z) + t1 = Tdouble_t(w * (_Lg2 + float64(w*(_Lg4+float64(w*_Lg6))))) + t2 = Tdouble_t(z * (_Lg1 + float64(w*(_Lg3+float64(w*(_Lg5+float64(w*_Lg7))))))) R = t2 + t1 /* See log2.c for details. */ /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */ @@ -109738,12 +109738,12 @@ func Xlog10(tls *TLS, x float64) (r float64) { *(*float64)(unsafe.Pointer(bp)) = hi *(*Tuint64_t)(unsafe.Pointer(bp)) &= Uint64FromInt32(-Int32FromInt32(1)) << Int32FromInt32(32) hi = *(*float64)(unsafe.Pointer(bp)) - lo = f - hi - hfsq + s*(hfsq+R) + lo = f - hi - hfsq + Tdouble_t(s*(hfsq+R)) /* val_hi+val_lo ~ log10(1+f) + k*log10(2) */ - val_hi = hi * _ivln10hi + val_hi = Tdouble_t(hi * _ivln10hi) dk = float64(k) - y = dk * _log10_2hi - val_lo = dk*_log10_2lo + (lo+hi)*_ivln10lo + lo*_ivln10hi + y = Tdouble_t(dk * _log10_2hi) + val_lo = Tdouble_t(dk*_log10_2lo) + Tdouble_t((lo+hi)*_ivln10lo) + Tdouble_t(lo*_ivln10hi) /* * Extra precision in for adding y is not strictly needed * since there is no very large cancellation near x = sqrt(2) or @@ -109793,7 +109793,7 @@ func Xlog10f(tls *TLS, x float32) (r float32) { k = 0 if ix < uint32(0x00800000) || ix>>int32(31) != 0 { /* x < 2**-126 */ if ix<<int32(1) == uint32(0) { - return float32(-Int32FromInt32(1)) / (x * x) + return float32(-Int32FromInt32(1)) / float32(x*x) } /* log(+-0)=-inf */ if ix>>int32(31) != 0 { return (x - x) / Float32FromFloat32(0) @@ -109820,19 +109820,19 @@ func Xlog10f(tls *TLS, x float32) (r float32) { x = *(*float32)(unsafe.Pointer(bp)) f = x - Float32FromFloat32(1) s = f / (Float32FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg21 + w*_Lg41) - t2 = z * (_Lg11 + w*_Lg31) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (_Lg21 + float32(w*_Lg41))) + t2 = Tfloat_t(z * (_Lg11 + float32(w*_Lg31))) R = t2 + t1 - hfsq = Float32FromFloat32(0.5) * f * f + hfsq = Tfloat_t(float32(Float32FromFloat32(0.5)*f) * f) hi = f - hfsq *(*float32)(unsafe.Pointer(bp)) = hi *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0xfffff000) hi = *(*float32)(unsafe.Pointer(bp)) - lo = f - hi - hfsq + s*(hfsq+R) + lo = f - hi - hfsq + Tfloat_t(s*(hfsq+R)) dk = float32(k) - return dk*_log10_2lo1 + (lo+hi)*_ivln10lo1 + lo*_ivln10hi1 + hi*_ivln10hi1 + dk*_log10_2hi1 + return Tfloat_t(dk*_log10_2lo1) + Tfloat_t((lo+hi)*_ivln10lo1) + Tfloat_t(lo*_ivln10hi1) + Tfloat_t(hi*_ivln10hi1) + Tfloat_t(dk*_log10_2hi1) } func Xlog10l(tls *TLS, x float64) (r float64) { @@ -109937,15 +109937,15 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hu)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff) f = *(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1) } - hfsq = float64(0.5) * f * f + hfsq = Tdouble_t(float64(float64(0.5)*f) * f) s = f / (Float64FromFloat64(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg22 + w*(_Lg42+w*_Lg61)) - t2 = z * (_Lg12 + w*(_Lg32+w*(_Lg51+w*_Lg71))) + z = Tdouble_t(s * s) + w = Tdouble_t(z * z) + t1 = Tdouble_t(w * (_Lg22 + float64(w*(_Lg42+float64(w*_Lg61))))) + t2 = Tdouble_t(z * (_Lg12 + float64(w*(_Lg32+float64(w*(_Lg51+float64(w*_Lg71))))))) R = t2 + t1 dk = float64(k) - return s*(hfsq+R) + (dk*_ln2_lo2 + c) - hfsq + f + dk*_ln2_hi2 + return Tdouble_t(s*(hfsq+R)) + (Tdouble_t(dk*_ln2_lo2) + c) - hfsq + f + Tdouble_t(dk*_ln2_hi2) } var _ln2_hi3 = float32(0.69313812256) /* 0x3f317180 */ @@ -109994,7 +109994,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint32(4) == uint32(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint32(4) == uint32(8) { y1 = float64(x3 * x3) @@ -110038,14 +110038,14 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { f = *(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1) } s = f / (Float32FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg23 + w*_Lg43) - t2 = z * (_Lg13 + w*_Lg33) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (_Lg23 + float32(w*_Lg43))) + t2 = Tfloat_t(z * (_Lg13 + float32(w*_Lg33))) R = t2 + t1 - hfsq = Float32FromFloat32(0.5) * f * f + hfsq = Tfloat_t(float32(Float32FromFloat32(0.5)*f) * f) dk = float32(k) - return s*(hfsq+R) + (dk*_ln2_lo3 + c) - hfsq + f + dk*_ln2_hi3 + return Tfloat_t(s*(hfsq+R)) + (Tfloat_t(dk*_ln2_lo3) + c) - hfsq + f + Tfloat_t(dk*_ln2_hi3) } func Xlog1pl(tls *TLS, x float64) (r float64) { @@ -110099,15 +110099,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { v6 = *(*Tuint64_t)(unsafe.Pointer(&v7)) & (-Uint64FromUint64(1) << Int32FromInt32(32)) rhi = *(*float64)(unsafe.Pointer(&v6)) rlo = r - rhi - hi = rhi * X__log2_data.Finvln2hi - lo = rlo*X__log2_data.Finvln2hi + r*X__log2_data.Finvln2lo - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(rhi * X__log2_data.Finvln2hi) + lo = Tdouble_t(rlo*X__log2_data.Finvln2hi) + Tdouble_t(r*X__log2_data.Finvln2lo) + r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ + r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))) + p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo += hi - y1 + p - lo += r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)) + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))) + r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8))+r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))) + lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 += lo y = y1 v8 = y @@ -110128,7 +110128,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v11 = x1 * float64(4.503599627370496e+15) + v11 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v11)) ix -= Uint64FromUint64(52) << Int32FromInt32(52) } @@ -110152,7 +110152,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* rounding error: 0x1p-55/N + 0x1p-65. */ - r = (z - (*(*struct { + r = Tdouble_t((z - (*(*struct { F__ccgo_align [0]uint32 Fchi float64 Fclo float64 @@ -110160,25 +110160,25 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { F__ccgo_align [0]uint32 Fchi float64 Fclo float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 1168 + uintptr(i)*16))).Fclo) * invc + })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 1168 + uintptr(i)*16))).Fclo) * invc) v13 = r v12 = *(*Tuint64_t)(unsafe.Pointer(&v13)) & (-Uint64FromUint64(1) << Int32FromInt32(32)) rhi1 = *(*float64)(unsafe.Pointer(&v12)) rlo1 = r - rhi1 - t1 = rhi1 * X__log2_data.Finvln2hi - t2 = rlo1*X__log2_data.Finvln2hi + r*X__log2_data.Finvln2lo + t1 = Tdouble_t(rhi1 * X__log2_data.Finvln2hi) + t2 = Tdouble_t(rlo1*X__log2_data.Finvln2hi) + Tdouble_t(r*X__log2_data.Finvln2lo) /* hi + lo = r/ln2 + log2(c) + k. */ t3 = kd + logc hi = t3 + t1 lo = t3 - hi + t1 + t2 /* log2(r+1) = r/ln2 + r^2*poly(r). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r /* rounding error: 0x1p-54/N^2. */ - r4 = r2 * r2 + r2 = Tdouble_t(r * r) /* rounding error: 0x1p-54/N^2. */ + r4 = Tdouble_t(r2 * r2) /* Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8)) + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))) + r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))) - y1 = lo + r2*p + hi + p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + y1 = lo + Tdouble_t(r2*p) + hi y = y1 v14 = y goto _15 @@ -110244,7 +110244,7 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { return X__math_invalidf(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * Float32FromFloat32(8.388608e+06) + v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } @@ -110268,14 +110268,14 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ - r = z*invc - Float64FromInt32(1) + r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ - r2 = r * r - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2 + y1 - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r + y0 - y1 = y1*r2 + p + r2 = Tdouble_t(r * r) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = Tdouble_t(y1*r2) + p y = float32(y1) v2 = y goto _3 @@ -110347,10 +110347,10 @@ func Xlogb(tls *TLS, x float64) (r float64) { goto _2 _2: if !(BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0) { - return x * x + return float64(x * x) } if x == Float64FromInt32(0) { - return float64(-Int32FromInt32(1)) / (x * x) + return float64(-Int32FromInt32(1)) / float64(x*x) } return float64(Xilogb(tls, x)) } @@ -110373,10 +110373,10 @@ func Xlogbf(tls *TLS, x float32) (r float32) { goto _2 _2: if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { - return x * x + return float32(x * x) } if x == Float32FromInt32(0) { - return float32(-Int32FromInt32(1)) / (x * x) + return float32(-Int32FromInt32(1)) / float32(x*x) } return float32(Xilogbf(tls, x)) } @@ -110400,10 +110400,10 @@ func Xlogbl(tls *TLS, x float64) (r float64) { goto _2 _2: if !(BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0) { - return x * x + return float64(x * x) } if x == Float64FromInt32(0) { - return float64(-Int32FromInt32(1)) / (x * x) + return float64(-Int32FromInt32(1)) / float64(x*x) } return float64(Xilogbl(tls, x)) } @@ -110447,7 +110447,7 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { return X__math_invalidf(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * Float32FromFloat32(8.388608e+06) + v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } @@ -110470,13 +110470,13 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ - r = z*invc - Float64FromInt32(1) - y0 = logc + float64(k)*X__logf_data.Fln2 + r = Tdouble_t(z*invc) - Float64FromInt32(1) + y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ - r2 = r * r - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2 + y1 - y1 = y1*r2 + (y0 + r) + r2 = Tdouble_t(r * r) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v2 = y goto _3 @@ -110846,12 +110846,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint32(8) == uint32(4) { - y = float32(x3*x3 + *(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8))) + y = float32(float64(x3*x3) + float64(*(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8)))) } else { if uint32(8) == uint32(8) { - y1 = x3*x3 + *(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8)) + y1 = float64(x3*x3) + float64(*(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8))) } else { - y2 = x3*x3 + *(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8)) + y2 = float64(x3*x3) + float64(*(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8))) } } } @@ -110946,12 +110946,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint32(4) == uint32(4) { - y = x3*x3 + *(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4)) + y = float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4))) } else { if uint32(4) == uint32(8) { - y1 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4))) + y1 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4)))) } else { - y2 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4))) + y2 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4)))) } } } @@ -111074,12 +111074,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint32(4) == uint32(4) { - y = x3*x3 + *(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16)) + y = float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16))) } else { if uint32(4) == uint32(8) { - y1 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16))) + y1 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16)))) } else { - y2 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16))) + y2 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16)))) } } } @@ -111159,25 +111159,25 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { /* Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|. */ zhi = *(*float64)(unsafe.Pointer(&v1)) zlo = z - zhi - rhi = zhi*invc - float64(1) - rlo = zlo * invc + rhi = Tdouble_t(zhi*invc) - float64(1) + rlo = Tdouble_t(zlo * invc) r = rhi + rlo /* k*Ln2 + log(c) + r. */ - t1 = kd*X__pow_log_data.Fln2hi + logc + t1 = Tdouble_t(kd*X__pow_log_data.Fln2hi) + logc t2 = t1 + r - lo1 = kd*X__pow_log_data.Fln2lo + logctail + lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r /* A[0] = -0.5. */ - ar2 = r * ar - ar3 = r * ar2 + ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar2 = Tdouble_t(r * ar) + ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ - arhi = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * rhi - arhi2 = rhi * arhi + arhi = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * rhi) + arhi2 = Tdouble_t(rhi * arhi) hi = t2 + arhi2 - lo3 = rlo * (ar + arhi) + lo3 = Tdouble_t(rlo * (ar + arhi)) lo4 = t2 - hi + arhi2 /* p = log1p(r) - r - A[0]*r*r. */ - p = ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8)) + ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8))+ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))) + p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo @@ -111202,7 +111202,7 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl /* k > 0, the exponent of scale might have overflowed by <= 460. */ sbits -= Uint64FromUint64(1009) << Int32FromInt32(52) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = float64(5.486124068793689e+303) * (scale + scale*tmp) + y3 = Tdouble_t(float64(5.486124068793689e+303) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -111213,13 +111213,13 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl sbits += Uint64FromUint64(1022) << Int32FromInt32(52) /* Note: sbits is signed scale. */ scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = scale + scale*tmp + y3 = scale + Tdouble_t(scale*tmp) if Xfabs(tls, y3) < float64(1) { one = float64(1) if y3 < float64(0) { one = -Float64FromFloat64(1) } - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = one + y3 lo = one - hi + y3 + lo y = hi + lo @@ -111237,9 +111237,9 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl v6 = y1 goto _7 _7: - y2 = v6 * float64(2.2250738585072014e-308) + y2 = float64(v6 * float64(2.2250738585072014e-308)) } - y3 = float64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(float64(2.2250738585072014e-308) * y3) y = y3 v8 = y goto _9 @@ -111284,7 +111284,7 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( } /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ - z = X__exp_data.Finvln2N * x1 + z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift v3 = y @@ -111294,7 +111294,7 @@ _4: v5 = kd ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) kd -= X__exp_data.Fshift - r = x1 + kd*X__exp_data.Fnegln2hiN + kd*X__exp_data.Fnegln2loN + r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ r += xtail /* 2^(k/N) ~= scale * (1 + tail). */ @@ -111306,17 +111306,17 @@ _4: sbits = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 112 + uintptr(idx+uint64(1))*8)) + top /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r + r2 = Tdouble_t(r * r) /* Without fma the worst case error is 0.25/N ulp larger. */ /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. */ - tmp = tail + r + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))) + r2*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))) + tmp = tail + r + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))))) + Tdouble_t(Tdouble_t(r2*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))))) if abstop == uint32(0) { return _specialcase2(tls, tmp, sbits, ki) } scale = *(*float64)(unsafe.Pointer(&sbits)) /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ - y = scale + scale*tmp + y = scale + Tdouble_t(scale*tmp) v7 = y goto _8 _8: @@ -111404,10 +111404,10 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ - return y1 * y1 + return float64(y1 * y1) } if _zeroinfnan(tls, ix) != 0 { - x2 = x1 * x1 + x2 = Tdouble_t(x1 * x1) if ix>>int32(63) != 0 && _checkint(tls, iy) == int32(1) { x2 = -x2 } @@ -111467,7 +111467,7 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = x1 * float64(4.503599627370496e+15) + v15 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) ix &= uint64(0x7fffffffffffffff) ix -= Uint64FromUint64(52) << Int32FromInt32(52) @@ -111481,8 +111481,8 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { v17 = *(*Tuint64_t)(unsafe.Pointer(&v18)) & (-Uint64FromUint64(1) << Int32FromInt32(27)) lhi = *(*float64)(unsafe.Pointer(&v17)) llo = hi - lhi + *(*Tdouble_t)(unsafe.Pointer(bp)) - ehi = yhi * lhi - elo = ylo*lhi + y1*llo /* |elo| < |ehi| * 2^-25. */ + ehi = Tdouble_t(yhi * lhi) + elo = Tdouble_t(ylo*lhi) + Tdouble_t(y1*llo) /* |elo| < |ehi| * 2^-25. */ return _exp_inline(tls, ehi, elo, sign_bias) } @@ -111547,16 +111547,16 @@ func _log2_inline(tls *TLS, ix Tuint32_t) (r1 Tdouble_t) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ - r = z*invc - Float64FromInt32(1) + r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ - r2 = r * r - y = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) - r4 = r2 * r2 - q = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r + y0 - q = p*r2 + q - y = y*r4 + q + r2 = Tdouble_t(r * r) + y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + r4 = Tdouble_t(r2 * r2) + q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = Tdouble_t(p*r2) + q + y = Tdouble_t(y*r4) + q return y } @@ -111586,11 +111586,11 @@ _2: ski = ki + uint64(sign_bias) t += ski << (Int32FromInt32(52) - Int32FromInt32(EXP2F_TABLE_BITS)) s = *(*float64)(unsafe.Pointer(&t)) - z = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) - r2 = r * r - y2 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r + Float64FromInt32(1) - y2 = z*r2 + y2 - y2 = y2 * s + z = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) + r2 = Tdouble_t(r * r) + y2 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r) + Float64FromInt32(1) + y2 = Tdouble_t(z*r2) + y2 + y2 = Tdouble_t(y2 * s) y = float32(y2) v4 = y goto _5 @@ -111658,10 +111658,10 @@ func Xpowf(tls *TLS, x1 float32, y1 float32) (r float32) { if BoolInt32(uint32(2)*ix < Uint32FromInt32(Int32FromInt32(2)*Int32FromInt32(0x3f800000))) == BoolInt32(!(iy&Uint32FromUint32(0x80000000) != 0)) { return Float32FromFloat32(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ - return y1 * y1 + return float32(y1 * y1) } if _zeroinfnan1(tls, ix) != 0 { - x2 = x1 * x1 + x2 = Tfloat_t(x1 * x1) if ix&uint32(0x80000000) != 0 && _checkint1(tls, iy) == int32(1) { x2 = -x2 } @@ -111692,22 +111692,22 @@ func Xpowf(tls *TLS, x1 float32, y1 float32) (r float32) { } if ix < uint32(0x00800000) { /* Normalize subnormal x so exponent becomes negative. */ - v4 = x1 * Float32FromFloat32(8.388608e+06) + v4 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v4)) ix &= uint32(0x7fffffff) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } } logx = _log2_inline(tls, ix) - ylogx = float64(y1) * logx /* cannot overflow, y is single prec. */ + ylogx = Tdouble_t(float64(y1) * logx) /* cannot overflow, y is single prec. */ v5 = ylogx - v6 = float64(126) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)) + v6 = float64(float64(126) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))) if *(*Tuint64_t)(unsafe.Pointer(&v5))>>int32(47)&uint64(0xffff) >= *(*Tuint64_t)(unsafe.Pointer(&v6))>>int32(47) { /* |y*log(x)| >= 126. */ - if ylogx > float64(127.99999995700433)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)) { + if ylogx > Tdouble_t(float64(127.99999995700433)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))) { return X__math_oflowf(tls, sign_bias) } - if ylogx <= -Float64FromFloat64(150)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)) { + if ylogx <= Tdouble_t(-Float64FromFloat64(150)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))) { return X__math_uflowf(tls, sign_bias) } } @@ -111840,7 +111840,7 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { _2: } if v3 || BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 || ex == int32(0x7ff) { - return x * y / (x * y) + return float64(x*y) / float64(x*y) } if *(*Tuint64_t)(unsafe.Pointer(bp + 8))<<int32(1) == uint64(0) { return x @@ -111938,7 +111938,7 @@ end: if sy != 0 { y = -y } - if ex == ey || ex+int32(1) == ey && (Float64FromInt32(2)*x > y || Float64FromInt32(2)*x == y && q%uint32(2) != 0) { + if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { x -= y q++ } @@ -112011,7 +112011,7 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { _2: } if v3 || BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 || ex == int32(0xff) { - return x * y / (x * y) + return float32(x*y) / float32(x*y) } if *(*Tuint32_t)(unsafe.Pointer(bp + 4))<<int32(1) == uint32(0) { return x @@ -112109,7 +112109,7 @@ end: if sy != 0 { y = -y } - if ex == ey || ex+int32(1) == ey && (Float32FromInt32(2)*x > y || Float32FromInt32(2)*x == y && q%uint32(2) != 0) { + if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { x -= y q++ } @@ -112292,10 +112292,10 @@ func Xround(tls *TLS, x3 float64) (r float64) { if uint32(8) == uint32(8) { y1 = x3 + _toint6 } else { - y2 = x3 + _toint6 + y2 = float64(x3 + _toint6) } } - return Float64FromInt32(0) * *(*float64)(unsafe.Pointer(bp)) + return float64(Float64FromInt32(0) * *(*float64)(unsafe.Pointer(bp))) } y3 = x3 + _toint6 - _toint6 - x3 if y3 > float64(0.5) { @@ -112359,7 +112359,7 @@ func Xroundf(tls *TLS, x3 float32) (r float32) { y2 = float64(x3 + _toint7) } } - return Float32FromInt32(0) * *(*float32)(unsafe.Pointer(bp)) + return float32(Float32FromInt32(0) * *(*float32)(unsafe.Pointer(bp))) } y3 = x3 + _toint7 - _toint7 - x3 if y3 > Float32FromFloat32(0.5) { @@ -112414,7 +112414,7 @@ _2: _4: } if v5 || BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { - return x * fn + return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn v6 = *(*uint64)(unsafe.Pointer(bp)) @@ -112422,7 +112422,7 @@ _2: _7: if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0) { if fn > float64(0) { - return x * fn + return float64(x * fn) } else { return x / -fn } @@ -112465,7 +112465,7 @@ _2: _4: } if v5 || BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { - return x * fn + return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn v6 = *(*uint32)(unsafe.Pointer(bp)) @@ -112473,7 +112473,7 @@ _2: _7: if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { - return x * fn + return float32(x * fn) } else { return x / -fn } @@ -112498,8 +112498,8 @@ func Xscalbln(tls *TLS, x float64, n int32) (r float64) { if n > int32(INT_MAX) { n = int32(INT_MAX) } else { - if n < -Int32FromInt32(1)-Int32FromInt32(0x7fffffff) { - n = -Int32FromInt32(1) - Int32FromInt32(0x7fffffff) + if n < int32(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { + n = int32(-Int32FromInt32(1) - Int32FromInt32(0x7fffffff)) } } return Xscalbn(tls, x, n) @@ -112513,8 +112513,8 @@ func Xscalblnf(tls *TLS, x float32, n int32) (r float32) { if n > int32(INT_MAX) { n = int32(INT_MAX) } else { - if n < -Int32FromInt32(1)-Int32FromInt32(0x7fffffff) { - n = -Int32FromInt32(1) - Int32FromInt32(0x7fffffff) + if n < int32(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { + n = int32(-Int32FromInt32(1) - Int32FromInt32(0x7fffffff)) } } return Xscalbnf(tls, x, n) @@ -112557,10 +112557,10 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15) + y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) n += Int32FromInt32(1022) - Int32FromInt32(53) if n < -int32(1022) { - y *= Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15) + y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) n += Int32FromInt32(1022) - Int32FromInt32(53) if n < -int32(1022) { n = -int32(1022) @@ -112569,7 +112569,7 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { } } *(*Tuint64_t)(unsafe.Pointer(bp)) = Uint64FromInt32(Int32FromInt32(0x3ff)+n) << int32(52) - x = y * *(*float64)(unsafe.Pointer(bp)) + x = float64(y * *(*float64)(unsafe.Pointer(bp))) return x } @@ -112599,10 +112599,10 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { } } else { if n < -int32(126) { - y *= Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07) + y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) n += Int32FromInt32(126) - Int32FromInt32(24) if n < -int32(126) { - y *= Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07) + y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) n += Int32FromInt32(126) - Int32FromInt32(24) if n < -int32(126) { n = -int32(126) @@ -112611,7 +112611,7 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { } } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32(Int32FromInt32(0x7f)+n) << int32(23) - x = y * *(*float32)(unsafe.Pointer(bp)) + x = float32(y * *(*float32)(unsafe.Pointer(bp))) return x } @@ -112793,10 +112793,10 @@ const M_PI_25 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _s1pio2 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _s2pio2 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _s3pio2 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _s4pio2 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _s1pio2 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _s2pio2 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _s3pio2 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _s4pio2 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { if __ccgo_strace { @@ -112955,10 +112955,10 @@ const M_PI_27 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _s1pio21 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _s2pio21 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _s3pio21 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _s4pio21 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _s1pio21 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _s2pio21 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _s3pio21 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _s4pio21 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xsinf(tls *TLS, x3 float32) (r float32) { if __ccgo_strace { @@ -113106,14 +113106,14 @@ func Xsinh(tls *TLS, x float64) (r float64) { /* note: this branch avoids spurious underflow */ return x } - return h * (Float64FromInt32(2)*t - t*t/(t+Float64FromInt32(1))) + return float64(h * (float64(Float64FromInt32(2)*t) - float64(t*t)/(t+Float64FromInt32(1)))) } /* note: |x|>log(0x1p26)+eps could be just h*exp(x) */ - return h * (t + t/(t+Float64FromInt32(1))) + return float64(h * (t + t/(t+Float64FromInt32(1)))) } /* |x| > log(DBL_MAX) or nan */ /* note: the result is stored to handle overflow */ - t = X__expo2(tls, absx, Float64FromInt32(2)*h) + t = X__expo2(tls, absx, float64(Float64FromInt32(2)*h)) return t } @@ -113154,12 +113154,12 @@ func Xsinhf(tls *TLS, x float32) (r float32) { if w < Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(12)<<Int32FromInt32(23)) { return x } - return h * (Float32FromInt32(2)*t - t*t/(t+Float32FromInt32(1))) + return float32(h * (float32(Float32FromInt32(2)*t) - float32(t*t)/(t+Float32FromInt32(1)))) } - return h * (t + t/(t+Float32FromInt32(1))) + return float32(h * (t + t/(t+Float32FromInt32(1)))) } /* |x| > logf(FLT_MAX) or nan */ - t = X__expo2f(tls, absx, Float32FromInt32(2)*h) + t = X__expo2f(tls, absx, float32(Float32FromInt32(2)*h)) return t } @@ -113226,7 +113226,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * float64(4.503599627370496e+15) + v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) top -= uint64(52) @@ -113376,7 +113376,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { return X__math_invalidf(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * Float32FromFloat32(8.388608e+06) + v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } @@ -113509,10 +113509,10 @@ const M_PI_29 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _t1pio2 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _t2pio2 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _t3pio2 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _t4pio2 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _t1pio2 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _t2pio2 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _t3pio2 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _t4pio2 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xtanf(tls *TLS, x3 float32) (r float32) { if __ccgo_strace { @@ -113652,18 +113652,18 @@ func Xtanh(tls *TLS, x3 float64) (r float64) { /* note: this branch avoids raising overflow */ t = Float64FromInt32(1) - Float64FromInt32(0)/x3 } else { - t = Xexpm1(tls, Float64FromInt32(2)*x3) + t = Xexpm1(tls, float64(Float64FromInt32(2)*x3)) t = Float64FromInt32(1) - Float64FromInt32(2)/(t+Float64FromInt32(2)) } } else { if w > uint32(0x3fd058ae) { /* |x| > log(5/3)/2 ~= 0.2554 */ - t = Xexpm1(tls, Float64FromInt32(2)*x3) + t = Xexpm1(tls, float64(Float64FromInt32(2)*x3)) t = t / (t + Float64FromInt32(2)) } else { if w >= uint32(0x00100000) { /* |x| >= 0x1p-1022, up to 2ulp error in [0.1,0.2554] */ - t = Xexpm1(tls, float64(-Int32FromInt32(2))*x3) + t = Xexpm1(tls, float64(float64(-Int32FromInt32(2))*x3)) t = -t / (t + Float64FromInt32(2)) } else { /* |x| is subnormal */ @@ -113724,23 +113724,23 @@ func Xtanhf(tls *TLS, x3 float32) (r float32) { /* |x| > 10 */ t = Float32FromInt32(1) + Float32FromInt32(0)/x3 } else { - t = Xexpm1f(tls, Float32FromInt32(2)*x3) + t = Xexpm1f(tls, float32(Float32FromInt32(2)*x3)) t = Float32FromInt32(1) - Float32FromInt32(2)/(t+Float32FromInt32(2)) } } else { if w > uint32(0x3e82c578) { /* |x| > log(5/3)/2 ~= 0.2554 */ - t = Xexpm1f(tls, Float32FromInt32(2)*x3) + t = Xexpm1f(tls, float32(Float32FromInt32(2)*x3)) t = t / (t + Float32FromInt32(2)) } else { if w >= uint32(0x00800000) { /* |x| >= 0x1p-126 */ - t = Xexpm1f(tls, float32(-Int32FromInt32(2))*x3) + t = Xexpm1f(tls, float32(float32(-Int32FromInt32(2))*x3)) t = -t / (t + Float32FromInt32(2)) } else { /* |x| is subnormal */ if uint32(4) == uint32(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint32(4) == uint32(8) { y1 = float64(x3 * x3) @@ -113788,12 +113788,12 @@ func _sinpi(tls *TLS, x float64) (r float64) { _ = n /* argument reduction: x = |x| mod 2 */ /* spurious inexact when x is odd int */ - x = x * float64(0.5) - x = Float64FromInt32(2) * (x - Xfloor(tls, x)) + x = float64(x * float64(0.5)) + x = float64(Float64FromInt32(2) * (x - Xfloor(tls, x))) /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(n) * float64(0.5) + x -= float64(float64(n) * float64(0.5)) x *= _pi4 switch n { default: /* case 4 */ @@ -113889,8 +113889,8 @@ func _S(tls *TLS, x float64) (r float64) { if !(i >= 0) { break } - num = num*x + _Snum[i] - den = den*x + _Sden[i] + num = Tdouble_t(num*x) + _Snum[i] + den = Tdouble_t(den*x) + _Sden[i] goto _1 _1: ; @@ -113975,7 +113975,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y2 = float64(float32(Float64FromFloat64(1.1754943508222875e-38) / x3)) } } - if Xfloor(tls, x3)*float64(0.5) == Xfloor(tls, x3*float64(0.5)) { + if float64(Xfloor(tls, x3)*float64(0.5)) == Xfloor(tls, float64(x3*float64(0.5))) { return Float64FromInt32(0) } return -Float64FromFloat64(0) @@ -113999,17 +113999,17 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy -= absx } z = absx - float64(0.5) - r = _S(tls, absx) * Xexp(tls, -y3) + r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) if x3 < Float64FromInt32(0) { /* reflection formula for negative x */ /* sinpi(absx) is not 0, integers are already handled */ - r = -_pi4 / (_sinpi(tls, absx) * absx * r) + r = -_pi4 / float64(float64(_sinpi(tls, absx)*absx)*r) dy = -dy z = -z } - r += dy * (_gmhalf + Float64FromFloat64(0.5)) * r / y3 - z = Xpow(tls, y3, float64(0.5)*z) - y3 = r * z * z + r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + z = Xpow(tls, y3, float64(float64(0.5)*z)) + y3 = float64(Tdouble_t(r*z) * z) return y3 } @@ -114073,7 +114073,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if uint32(8) == uint32(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^m @@ -114164,7 +114164,7 @@ func Xa64l(tls *TLS, s uintptr) (r int32) { e += int32(6) s++ } - return Int32FromUint32(x) + return int32(Int32FromUint32(x)) } func Xl64a(tls *TLS, x0 int32) (r uintptr) { @@ -115175,7 +115175,7 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var v1, v2 uint64 var _ /* k_rlim at bp+0 */ [2]uint32 _, _, _ = ret, v1, v2 - ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_prlimit64), Int32FromInt32(0), resource, Int32FromInt32(0), int32(rlim)))) + ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_prlimit64), int32(Int32FromInt32(0)), resource, int32(Int32FromInt32(0)), int32(rlim)))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) @@ -115223,7 +115223,7 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { var _ /* kru at bp+0 */ [4]int32 _, _ = dest, r dest = ru + 32 - uintptr(Uint32FromInt32(4)*Uint32FromInt64(4)) - r = X__syscall2(tls, int32(SYS_getrusage), who, int32(dest)) + r = int32(X__syscall2(tls, int32(SYS_getrusage), who, int32(dest))) if !(r != 0) && Bool(uint32(8) > uint32(4)) { _memcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ @@ -115621,7 +115621,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { ap = va arg = VaUintptr(&ap) _ = ap - r = X__syscall3(tls, int32(SYS_ioctl), fd, req, int32(arg)) + r = int32(X__syscall3(tls, int32(SYS_ioctl), fd, req, int32(arg))) if Bool(Uint32FromUint32(2)<<Int32FromInt32(30)|Uint32FromInt32(Int32FromInt32(0x89)<<Int32FromInt32(8))|Uint32FromInt32(Int32FromInt32(6))|Uint32FromInt64(16)<<Int32FromInt32(16) != uint32(SIOCGSTAMP_OLD)) && req != 0 && r == -int32(ENOTTY) { i = 0 for { @@ -115632,7 +115632,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 } _convert_ioctl_struct(tls, uintptr(unsafe.Pointer(&_compat_map))+uintptr(i)*20, bp, arg, int32(W)) - r = X__syscall3(tls, int32(SYS_ioctl), fd, _compat_map[i].Fold_req, int32(bp)) + r = int32(X__syscall3(tls, int32(SYS_ioctl), fd, _compat_map[i].Fold_req, int32(bp))) if r < 0 { break } @@ -116255,7 +116255,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if !(buf != 0) { len1 = uint32(0) } - v1 = X__syscall3(tls, int32(SYS_ioctl), fd, Int32FromUint32(Uint32FromUint32(TIOCGPTN)), int32(bp)) + v1 = int32(X__syscall3(tls, int32(SYS_ioctl), fd, Int32FromUint32(Uint32FromUint32(TIOCGPTN)), int32(bp))) err = v1 if v1 != 0 { return -err @@ -116529,7 +116529,7 @@ func _do_setrlimit(tls *TLS, p uintptr) { if (*Tctx)(unsafe.Pointer(c)).Ferr > 0 { return } - (*Tctx)(unsafe.Pointer(c)).Ferr = -X__syscall2(tls, int32(SYS_setrlimit), (*Tctx)(unsafe.Pointer(c)).Fres, int32(c)) + (*Tctx)(unsafe.Pointer(c)).Ferr = int32(-X__syscall2(tls, int32(SYS_setrlimit), (*Tctx)(unsafe.Pointer(c)).Fres, int32(c))) } func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { @@ -116554,7 +116554,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } rlim = bp } - ret = X__syscall4(tls, int32(SYS_prlimit64), Int32FromInt32(0), resource, int32(rlim), Int32FromInt32(0)) + ret = int32(X__syscall4(tls, int32(SYS_prlimit64), int32(Int32FromInt32(0)), resource, int32(rlim), int32(Int32FromInt32(0)))) if ret != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(ret)) } @@ -117279,7 +117279,7 @@ func Xposix_madvise(tls *TLS, addr uintptr, len1 Tsize_t, advice int32) (r int32 if advice == int32(MADV_DONTNEED) { return 0 } - return -X__syscall3(tls, int32(SYS_madvise), int32(addr), Int32FromUint32(len1), advice) + return int32(-X__syscall3(tls, int32(SYS_madvise), int32(addr), Int32FromUint32(len1), advice)) } func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { @@ -117374,7 +117374,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117575,7 +117575,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize *(*Twchar_t)(unsafe.Pointer(wc)) = v1 return BoolUint32(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -117746,7 +117746,7 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117974,7 +117974,7 @@ func Xmbtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t) (r int32) { *(*Twchar_t)(unsafe.Pointer(wc)) = v1 return BoolInt32(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -118044,7 +118044,7 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { *(*uint8)(unsafe.Pointer(s)) = uint8(wc) return uint32(1) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -118251,7 +118251,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -118286,15 +118286,15 @@ func Xaccept(tls *TLS, fd int32, addr uintptr, len1 uintptr) (r1 int32) { v2 = fd v3 = int32(addr) v4 = int32(len1) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if int32(1) != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -118332,14 +118332,14 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int v3 = int32(addr) v4 = int32(len1) v5 = flg - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if int32(1) != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -118359,10 +118359,10 @@ _9: return ret } if flg&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), ret, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), ret, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if flg&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), ret, Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) + X__syscall3(tls, int32(SYS_fcntl64), ret, int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } return ret } @@ -118380,15 +118380,15 @@ func Xbind(tls *TLS, fd int32, addr uintptr, len1 Tsocklen_t) (r1 int32) { v2 = fd v3 = int32(addr) v4 = Int32FromUint32(len1) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -118411,15 +118411,15 @@ func Xconnect(tls *TLS, fd int32, addr uintptr, len1 Tsocklen_t) (r1 int32) { v2 = fd v3 = int32(addr) v4 = Int32FromUint32(len1) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if int32(1) != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -121608,15 +121608,15 @@ func Xgetpeername(tls *TLS, fd int32, addr uintptr, len1 uintptr) (r1 int32) { v2 = fd v3 = int32(addr) v4 = int32(len1) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -121723,15 +121723,15 @@ func Xgetsockname(tls *TLS, fd int32, addr uintptr, len1 uintptr) (r1 int32) { v2 = fd v3 = int32(addr) v4 = int32(len1) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -121760,13 +121760,13 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, v4 = optname v5 = int32(optval) v6 = int32(optlen) - v7 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -121803,13 +121803,13 @@ _9: v13 = optname v14 = int32(bp + 8) v15 = int32(bp) - v16 = Int32FromInt32(0) + v16 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v10, v11, v12, v13, v14, v15, v16) } else { r = X__syscall6(tls, v10, v11, v12, v13, v14, v15, v16) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v17 = r goto _18 } @@ -121843,13 +121843,13 @@ _9: v22 = optname v23 = int32(optval) v24 = int32(optlen) - v25 = Int32FromInt32(0) + v25 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v19, v20, v21, v22, v23, v24, v25) } else { r = X__syscall6(tls, v19, v20, v21, v22, v23, v24, v25) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v26 = r goto _27 } @@ -121869,10 +121869,10 @@ func X__h_errno_location(tls *TLS) (r uintptr) { trc("tls=%v, (%v:)", tls, origin(2)) defer func() { trc("-> %v", r) }() } - if !((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Fstack != 0) { + if !((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fstack != 0) { return uintptr(unsafe.Pointer(&Xh_errno)) } - return ___get_tp(tls) + 80 + return uintptr(___get_tp(tls)) + 80 } func Xherror(tls *TLS, msg uintptr) { @@ -122616,16 +122616,16 @@ func Xlisten(tls *TLS, fd int32, backlog int32) (r1 int32) { _ = int32(__SC_listen) v2 = fd v3 = backlog - v4 = Int32FromInt32(0) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v4 = int32(Int32FromInt32(0)) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -123847,7 +123847,7 @@ func Xns_get32(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return uint32(*(*uint8)(unsafe.Pointer(cp)))<<int32(24) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp + 1)))<<int32(16)) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp + 2)))<<int32(8)) | uint32(*(*uint8)(unsafe.Pointer(cp + 3))) + return uint32(uint32(*(*uint8)(unsafe.Pointer(cp)))<<int32(24) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp + 1)))<<int32(16)) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp + 2)))<<int32(8)) | uint32(*(*uint8)(unsafe.Pointer(cp + 3)))) } func Xns_put16(tls *TLS, s uint32, cp uintptr) { @@ -124246,7 +124246,7 @@ func Xrecvfrom(tls *TLS, fd int32, buf uintptr, len1 Tsize_t, flags int32, addr } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -124292,7 +124292,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti } else { v3 = uintptr(0) } - r = ___syscall_cp(tls, int32(SYS_recvmmsg_time64), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v3), 0) + r = int32(___syscall_cp(tls, int32(SYS_recvmmsg_time64), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v3), 0)) if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -124319,14 +124319,14 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti v7 = uint64(0x7fffffff) + (0+Uint64FromInt64(s))>>int32(63) } *(*[2]int32)(unsafe.Pointer(bp + 16)) = [2]int32{ - 0: Int32FromUint64(v7), + 0: int32(Int32FromUint64(v7)), 1: ns, } v6 = bp + 16 } else { v6 = uintptr(0) } - r = ___syscall_cp(tls, int32(SYS_recvmmsg), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v6), 0) + r = int32(___syscall_cp(tls, int32(SYS_recvmmsg), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v6), 0)) i1 = 0 for { if !(i1 < r) { @@ -124402,10 +124402,10 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { goto _1 _1: ; - if (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len < uint32(12) || ((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(cmsg)) { + if (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(cmsg)) { v6 = uintptr(0) } else { - v6 = cmsg + uintptr(((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) + v6 = cmsg + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) } cmsg = v6 } @@ -124417,10 +124417,10 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } *(*Tsocklen_t)(unsafe.Pointer(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) - if (*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len < uint32(12) || ((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(last)) { + if (*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(last)) { v7 = uintptr(0) } else { - v7 = last + uintptr(((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) + v7 = last + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) } cmsg = v7 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) @@ -124445,15 +124445,15 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { v2 = fd v3 = int32(msg) v4 = flags - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if int32(1) != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125483,15 +125483,15 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { v2 = fd v3 = int32(msg) v4 = flags - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if int32(1) != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125522,7 +125522,7 @@ func Xsendto(tls *TLS, fd int32, buf uintptr, len1 Tsize_t, flags int32, addr ui } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125573,13 +125573,13 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, v4 = optname v5 = int32(optval) v6 = Int32FromUint32(optlen) - v7 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125619,7 +125619,7 @@ _9: } *(*[2]int32)(unsafe.Pointer(bp)) = [2]int32{ 0: int32(s), - 1: Int32FromUint64(v10), + 1: int32(Int32FromUint64(v10)), } v11 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) @@ -125628,13 +125628,13 @@ _9: v14 = optname v15 = int32(bp) v16 = Int32FromUint32(Uint32FromInt32(2) * Uint32FromInt64(4)) - v17 = Int32FromInt32(0) + v17 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v11, v12, v13, v14, v15, v16, v17) } else { r = X__syscall6(tls, v11, v12, v13, v14, v15, v16, v17) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v18 = r goto _19 } @@ -125661,13 +125661,13 @@ _9: v23 = optname v24 = int32(optval) v25 = Int32FromUint32(optlen) - v26 = Int32FromInt32(0) + v26 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v20, v21, v22, v23, v24, v25, v26) } else { r = X__syscall6(tls, v20, v21, v22, v23, v24, v25, v26) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v27 = r goto _28 } @@ -125694,16 +125694,16 @@ func Xshutdown(tls *TLS, fd int32, how int32) (r1 int32) { _ = int32(__SC_shutdown) v2 = fd v3 = how - v4 = Int32FromInt32(0) - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v4 = int32(Int32FromInt32(0)) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125740,15 +125740,15 @@ func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { v2 = domain v3 = type1 v4 = protocol - v5 = Int32FromInt32(0) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v5 = int32(Int32FromInt32(0)) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125760,17 +125760,17 @@ _9: v10 = int32(SYS_socket) _ = int32(__SC_socket) v11 = domain - v12 = type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK)) + v12 = int32(type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK))) v13 = protocol - v14 = Int32FromInt32(0) - v15 = Int32FromInt32(0) - v16 = Int32FromInt32(0) + v14 = int32(Int32FromInt32(0)) + v15 = int32(Int32FromInt32(0)) + v16 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v10, v11, v12, v13, v14, v15, v16) } else { r = X__syscall6(tls, v10, v11, v12, v13, v14, v15, v16) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v17 = r goto _18 } @@ -125782,10 +125782,10 @@ _9: return X__syscall_ret(tls, Uint32FromInt32(s)) } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), s, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), s, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), s, Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) + X__syscall3(tls, int32(SYS_fcntl64), s, int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } } return X__syscall_ret(tls, Uint32FromInt32(s)) @@ -125805,14 +125805,14 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr v3 = type1 v4 = protocol v5 = int32(fd) - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v8 = r goto _9 } @@ -125824,17 +125824,17 @@ _9: v10 = int32(SYS_socketpair) _ = int32(__SC_socketpair) v11 = domain - v12 = type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK)) + v12 = int32(type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK))) v13 = protocol v14 = int32(fd) - v15 = Int32FromInt32(0) - v16 = Int32FromInt32(0) + v15 = int32(Int32FromInt32(0)) + v16 = int32(Int32FromInt32(0)) if 0 != 0 { r = ___syscall_cp(tls, v10, v11, v12, v13, v14, v15, v16) } else { r = X__syscall6(tls, v10, v11, v12, v13, v14, v15, v16) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v17 = r goto _18 } @@ -125846,12 +125846,12 @@ _9: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -127417,7 +127417,7 @@ func Xjrand48(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - return Int32FromUint64(X__rand48_step(tls, s, uintptr(unsafe.Pointer(&X__seed48))+uintptr(3)*2) >> Int32FromInt32(16)) + return int32(Int32FromUint64(X__rand48_step(tls, s, uintptr(unsafe.Pointer(&X__seed48))+uintptr(3)*2) >> Int32FromInt32(16))) } func Xmrand48(tls *TLS) (r int32) { @@ -127930,7 +127930,7 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { var r int32 var _ /* buf at bp+0 */ [27]uint8 _ = r - r = X__syscall5(tls, int32(SYS_execveat), fd, int32(__ccgo_ts), int32(argv), int32(envp), Int32FromInt32(AT_EMPTY_PATH)) + r = int32(X__syscall5(tls, int32(SYS_execveat), fd, int32(__ccgo_ts), int32(argv), int32(envp), int32(Int32FromInt32(AT_EMPTY_PATH)))) if r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -128310,7 +128310,7 @@ func Xwaitid(tls *TLS, type1 Tidtype_t, id Tid_t, info uintptr, options int32) ( trc("tls=%v type1=%v id=%v info=%v options=%v, (%v:)", tls, type1, id, info, options, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_waitid), type1, Int32FromUint32(id), int32(info), options, Int32FromInt32(0), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_waitid), type1, Int32FromUint32(id), int32(info), options, int32(Int32FromInt32(0)), 0))) } func Xwaitpid(tls *TLS, pid Tpid_t, status uintptr, options int32) (r Tpid_t) { @@ -128318,7 +128318,7 @@ func Xwaitpid(tls *TLS, pid Tpid_t, status uintptr, options int32) (r Tpid_t) { trc("tls=%v pid=%v status=%v options=%v, (%v:)", tls, pid, status, options, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_wait4), pid, int32(status), options, Int32FromInt32(0), 0, 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_wait4), pid, int32(status), options, int32(Int32FromInt32(0)), 0, 0))) } const BRACKET = -3 @@ -128637,7 +128637,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v8 = int32(4) } else { v8 = int32(1) @@ -130185,8 +130185,8 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { err = int32(REG_ESPACE) goto parse_bracket_done } - (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min = Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1) - (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1) + (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min = int32(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) + (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int32(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ if (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 != 0 { @@ -134855,7 +134855,7 @@ func Xppoll(tls *TLS, fds uintptr, n Tnfds_t, to uintptr, mask uintptr) (r1 int3 } else { v3 = uintptr(0) } - r = ___syscall_cp(tls, int32(SYS_ppoll_time64), int32(fds), Int32FromUint32(n), int32(v3), int32(mask), Int32FromInt32(_NSIG)/Int32FromInt32(8), 0) + r = int32(___syscall_cp(tls, int32(SYS_ppoll_time64), int32(fds), Int32FromUint32(n), int32(v3), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0)) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -134875,7 +134875,7 @@ func Xppoll(tls *TLS, fds uintptr, n Tnfds_t, to uintptr, mask uintptr) (r1 int3 } else { v5 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ppoll), int32(fds), Int32FromUint32(n), int32(v5), int32(mask), Int32FromInt32(_NSIG)/Int32FromInt32(8), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ppoll), int32(fds), Int32FromUint32(n), int32(v5), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0))) } type t__ucontext4 = Tucontext_t4 @@ -134896,7 +134896,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 24)) = [2]Tsyscall_arg_t{ 0: Int32FromUint32(uint32(mask)), - 1: Int32FromInt32(_NSIG) / Int32FromInt32(8), + 1: int32(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } if ts != 0 { v1 = (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec @@ -134921,7 +134921,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui } else { v3 = uintptr(0) } - r = ___syscall_cp(tls, int32(SYS_pselect6_time64), n, int32(rfds), int32(wfds), int32(efds), int32(v3), int32(bp+24)) + r = int32(___syscall_cp(tls, int32(SYS_pselect6_time64), n, int32(rfds), int32(wfds), int32(efds), int32(v3), int32(bp+24))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -135005,9 +135005,9 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin v3 = uintptr(0) } *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ - 1: Int32FromInt32(_NSIG) / Int32FromInt32(8), + 1: int32(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } - r = ___syscall_cp(tls, int32(SYS_pselect6_time64), n, int32(rfds), int32(wfds), int32(efds), int32(v3), int32(bp+16)) + r = int32(___syscall_cp(tls, int32(SYS_pselect6_time64), n, int32(rfds), int32(wfds), int32(efds), int32(v3), int32(bp+16))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -135044,21 +135044,21 @@ func X__block_all_sigs(tls *TLS, set uintptr) { if __ccgo_strace { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) } - X__syscall4(tls, int32(SYS_rt_sigprocmask), Int32FromInt32(SIG_BLOCK), int32(uintptr(unsafe.Pointer(&_all_mask))), int32(set), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + X__syscall4(tls, int32(SYS_rt_sigprocmask), int32(Int32FromInt32(SIG_BLOCK)), int32(uintptr(unsafe.Pointer(&_all_mask))), int32(set), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } func X__block_app_sigs(tls *TLS, set uintptr) { if __ccgo_strace { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) } - X__syscall4(tls, int32(SYS_rt_sigprocmask), Int32FromInt32(SIG_BLOCK), int32(uintptr(unsafe.Pointer(&_app_mask))), int32(set), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + X__syscall4(tls, int32(SYS_rt_sigprocmask), int32(Int32FromInt32(SIG_BLOCK)), int32(uintptr(unsafe.Pointer(&_app_mask))), int32(set), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } func X__restore_sigs(tls *TLS, set uintptr) { if __ccgo_strace { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) } - X__syscall4(tls, int32(SYS_rt_sigprocmask), Int32FromInt32(SIG_SETMASK), int32(set), Int32FromInt32(0), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + X__syscall4(tls, int32(SYS_rt_sigprocmask), int32(Int32FromInt32(SIG_SETMASK)), int32(set), int32(Int32FromInt32(0)), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { @@ -135072,7 +135072,7 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { var _ /* old32 at bp+0 */ [4]int32 _ = r if uint32(8) > uint32(4) { - r = X__syscall2(tls, int32(SYS_getitimer), which, int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_getitimer), which, int32(bp))) if !(r != 0) { (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]) @@ -135166,7 +135166,7 @@ func Xraise(tls *TLS, sig int32) (r int32) { var _ /* set at bp+0 */ Tsigset_t _ = ret X__block_app_sigs(tls, bp) - ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_tkill), (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid, sig))) + ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_tkill), (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid, sig))) X__restore_sigs(tls, bp) return ret } @@ -135210,7 +135210,7 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { 2: int32(vs), 3: vus, } - r = X__syscall3(tls, int32(SYS_setitimer), which, int32(bp), int32(bp+16)) + r = int32(X__syscall3(tls, int32(SYS_setitimer), which, int32(bp), int32(bp+16))) if !(r != 0) && old != 0 { (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[0]) (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(1)]) @@ -135317,7 +135317,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) *(*[2]uint32)(unsafe.Pointer(bp)) = [2]uint32{ 1: Uint32FromUint32(3) << (Int32FromInt32(32) * BoolInt32(Uint32FromInt64(4) > Uint32FromInt32(4))), } - X__syscall4(tls, int32(SYS_rt_sigprocmask), Int32FromInt32(SIG_UNBLOCK), int32(bp), Int32FromInt32(0), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + X__syscall4(tls, int32(SYS_rt_sigprocmask), int32(Int32FromInt32(SIG_UNBLOCK)), int32(bp), int32(Int32FromInt32(0)), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) _unmask_done = int32(1) } if !((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&Int32FromInt32(SA_RESTART) != 0) { @@ -135347,7 +135347,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) } else { v12 = uintptr(0) } - r = X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v11), int32(v12), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v11), int32(v12), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fhandler (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint32((*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fflags) @@ -135452,7 +135452,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) l = left r = right for { - if !(i < Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4)) { + if !(i < uint32(Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4))) { break } *(*uint32)(unsafe.Pointer(d + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer(l + uintptr(i)*4)) & *(*uint32)(unsafe.Pointer(r + uintptr(i)*4)) @@ -135569,7 +135569,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { l = left r = right for { - if !(i < Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4)) { + if !(i < uint32(Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4))) { break } *(*uint32)(unsafe.Pointer(d + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer(l + uintptr(i)*4)) | *(*uint32)(unsafe.Pointer(r + uintptr(i)*4)) @@ -135586,7 +135586,7 @@ func Xsigpending(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_rt_sigpending), int32(set), Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_rt_sigpending), int32(set), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8))))) } func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { @@ -135675,7 +135675,7 @@ func X__sigsetjmp_tail(tls *TLS, jb uintptr, ret int32) (r int32) { } else { v2 = p } - X__syscall4(tls, int32(SYS_rt_sigprocmask), Int32FromInt32(SIG_SETMASK), int32(v1), int32(v2), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + X__syscall4(tls, int32(SYS_rt_sigprocmask), int32(Int32FromInt32(SIG_SETMASK)), int32(v1), int32(v2), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) return ret } @@ -135684,7 +135684,7 @@ func Xsigsuspend(tls *TLS, mask uintptr) (r int32) { trc("tls=%v mask=%v, (%v:)", tls, mask, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_rt_sigsuspend), int32(mask), Int32FromInt32(_NSIG)/Int32FromInt32(8), 0, 0, 0, 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_rt_sigsuspend), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0, 0, 0))) } func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) { @@ -135719,7 +135719,7 @@ func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) } else { v3 = uintptr(0) } - r = ___syscall_cp(tls, int32(SYS_rt_sigtimedwait_time64), int32(mask), int32(si), int32(v3), Int32FromInt32(_NSIG)/Int32FromInt32(8), 0, 0) + r = int32(___syscall_cp(tls, int32(SYS_rt_sigtimedwait_time64), int32(mask), int32(si), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0)) } if Bool(false) || r != -int32(ENOSYS) { return r @@ -135731,14 +135731,14 @@ func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) v5 = uint64(0x7fffffff) + (0+Uint64FromInt64(s))>>int32(63) } *(*[2]int32)(unsafe.Pointer(bp + 16)) = [2]int32{ - 0: Int32FromUint64(v5), + 0: int32(Int32FromUint64(v5)), 1: ns, } v4 = bp + 16 } else { v4 = uintptr(0) } - return ___syscall_cp(tls, int32(SYS_rt_sigtimedwait), int32(mask), int32(si), int32(v4), Int32FromInt32(_NSIG)/Int32FromInt32(8), 0, 0) + return int32(___syscall_cp(tls, int32(SYS_rt_sigtimedwait), int32(mask), int32(si), int32(v4), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0)) return r1 } @@ -135812,8 +135812,8 @@ func Xfchmod(tls *TLS, fd int32, mode Tmode_t) (r int32) { var ret int32 var _ /* buf at bp+0 */ [27]uint8 _ = ret - ret = X__syscall2(tls, int32(SYS_fchmod), fd, Int32FromUint32(mode)) - if ret != -int32(EBADF) || X__syscall2(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_GETFD)) < 0 { + ret = int32(X__syscall2(tls, int32(SYS_fchmod), fd, Int32FromUint32(mode))) + if ret != -int32(EBADF) || X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFD))) < 0 { return X__syscall_ret(tls, Uint32FromInt32(ret)) } X__procfdname(tls, bp, Uint32FromInt32(fd)) @@ -135834,7 +135834,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if !(flag != 0) { return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fchmodat), fd, int32(path), Int32FromUint32(mode)))) } - ret = X__syscall4(tls, int32(SYS_fchmodat2), fd, int32(path), Int32FromUint32(mode), flag) + ret = int32(X__syscall4(tls, int32(SYS_fchmodat2), fd, int32(path), Int32FromUint32(mode), flag)) if ret != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(ret)) } @@ -135847,7 +135847,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } - v1 = X__syscall3(tls, int32(SYS_openat), fd, int32(path), Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)) + v1 = int32(X__syscall3(tls, int32(SYS_openat), fd, int32(path), int32(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) fd2 = v1 if v1 < 0 { if fd2 == -int32(ELOOP) { @@ -135861,7 +135861,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } else { - ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fchmodat), -Int32FromInt32(100), int32(bp+152), Int32FromUint32(mode)))) + ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fchmodat), int32(-Int32FromInt32(100)), int32(bp+152), Int32FromUint32(mode)))) } } X__syscall1(tls, int32(SYS_close), fd2) @@ -135939,7 +135939,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var _ /* stx at bp+0 */ Tstatx1 _ = ret flag |= int32(AT_NO_AUTOMOUNT) - ret = X__syscall5(tls, int32(SYS_statx), fd, int32(path), flag, Int32FromInt32(0x7ff), int32(bp)) + ret = int32(X__syscall5(tls, int32(SYS_statx), fd, int32(path), flag, int32(Int32FromInt32(0x7ff)), int32(bp))) if ret != 0 { return ret } @@ -136024,22 +136024,22 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var _ /* kst at bp+0 */ Tkstat _ = ret if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(*(*uint8)(unsafe.Pointer(path)) != 0) { - ret = X__syscall2(tls, int32(SYS_fstat64), fd, int32(bp)) - if ret == -int32(EBADF) && X__syscall2(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_GETFD)) >= 0 { - ret = X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag) + ret = int32(X__syscall2(tls, int32(SYS_fstat64), fd, int32(bp))) + if ret == -int32(EBADF) && X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFD))) >= 0 { + ret = int32(X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag)) if ret == -int32(EINVAL) { X__procfdname(tls, bp+104, Uint32FromInt32(fd)) - ret = X__syscall2(tls, int32(SYS_stat64), int32(bp+104), int32(bp)) + ret = int32(X__syscall2(tls, int32(SYS_stat64), int32(bp+104), int32(bp))) } } } else { if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { - ret = X__syscall2(tls, int32(SYS_lstat64), int32(path), int32(bp)) + ret = int32(X__syscall2(tls, int32(SYS_lstat64), int32(path), int32(bp))) } else { if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && !(flag != 0) { - ret = X__syscall2(tls, int32(SYS_stat64), int32(path), int32(bp)) + ret = int32(X__syscall2(tls, int32(SYS_stat64), int32(path), int32(bp))) } else { - ret = X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag) + ret = int32(X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag)) } } } @@ -136360,7 +136360,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r } else { v1 = uintptr(0) } - r = X__syscall4(tls, int32(SYS_utimensat_time64), fd, int32(path), int32(v1), flags) + r = int32(X__syscall4(tls, int32(SYS_utimensat_time64), fd, int32(path), int32(v1), flags)) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -136379,7 +136379,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r } else { v2 = uintptr(0) } - r = X__syscall4(tls, int32(SYS_utimensat), fd, int32(path), int32(v2), flags) + r = int32(X__syscall4(tls, int32(SYS_utimensat), fd, int32(path), int32(v2), flags)) if r != -int32(ENOSYS) || flags != 0 { return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -136405,11 +136405,11 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r i++ } } - r = X__syscall3(tls, int32(SYS_futimesat), fd, int32(path), int32(tv)) + r = int32(X__syscall3(tls, int32(SYS_futimesat), fd, int32(path), int32(tv))) if r != -int32(ENOSYS) || fd != -int32(100) { return X__syscall_ret(tls, Uint32FromInt32(r)) } - r = X__syscall2(tls, int32(SYS_utimes), int32(path), int32(tv)) + r = int32(X__syscall2(tls, int32(SYS_utimes), int32(path), int32(tv))) return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -136456,13 +136456,13 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { } /* Apply close-on-exec flag */ if Xstrchr(tls, mode, int32('e')) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { - flags = X__syscall2(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_GETFL)) + flags = int32(X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { - X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_SETFL), flags|Int32FromInt32(O_APPEND)) + X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFL)), int32(flags|Int32FromInt32(O_APPEND))) } *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) } @@ -136471,7 +136471,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint32(BUFSIZ) /* Activate line buffered mode for terminals */ (*TFILE)(unsafe.Pointer(f)).Flbf = -int32(1) - if !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_NOWR) != 0) && !(X__syscall3(tls, int32(SYS_ioctl), fd, Int32FromInt32(TIOCGWINSZ), int32(bp)) != 0) { + if !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_NOWR) != 0) && !(X__syscall3(tls, int32(SYS_ioctl), fd, int32(Int32FromInt32(TIOCGWINSZ)), int32(bp)) != 0) { (*TFILE)(unsafe.Pointer(f)).Flbf = int32('\n') } /* Initialize op ptrs. No problem if some are unneeded. */ @@ -136534,11 +136534,11 @@ func X__fopen_rb_ca(tls *TLS, filename uintptr, f uintptr, buf uintptr, len1 Tsi defer func() { trc("-> %v", r) }() } Xmemset(tls, f, 0, uint32(144)) - (*TFILE)(unsafe.Pointer(f)).Ffd = X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_open), int32(filename), Int32FromInt32(O_RDONLY)|Int32FromInt32(O_CLOEXEC)|Int32FromInt32(O_LARGEFILE)))) + (*TFILE)(unsafe.Pointer(f)).Ffd = X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_open), int32(filename), int32(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_CLOEXEC)|Int32FromInt32(O_LARGEFILE))))) if (*TFILE)(unsafe.Pointer(f)).Ffd < 0 { return uintptr(0) } - X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) (*TFILE)(unsafe.Pointer(f)).Fflags = Uint32FromInt32(Int32FromInt32(F_NOWR) | Int32FromInt32(F_PERM)) (*TFILE)(unsafe.Pointer(f)).Fbuf = buf + uintptr(UNGET) (*TFILE)(unsafe.Pointer(f)).Fbuf_size = len1 - uint32(UNGET) @@ -136659,7 +136659,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { }, } if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { - v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_readv), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(bp), Int32FromInt32(2)))) + v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_readv), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(bp), int32(Int32FromInt32(2))))) } else { v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_read), (*TFILE)(unsafe.Pointer(f)).Ffd, int32((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int32FromUint32((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) } @@ -136769,7 +136769,7 @@ func X__stdout_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) defer tls.Free(16) var _ /* wsz at bp+0 */ Twinsize (*TFILE)(unsafe.Pointer(f)).Fwrite = __ccgo_fp(X__stdio_write) - if !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_SVB) != 0) && X__syscall3(tls, int32(SYS_ioctl), (*TFILE)(unsafe.Pointer(f)).Ffd, Int32FromInt32(TIOCGWINSZ), int32(bp)) != 0 { + if !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_SVB) != 0) && X__syscall3(tls, int32(SYS_ioctl), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(TIOCGWINSZ)), int32(bp)) != 0 { (*TFILE)(unsafe.Pointer(f)).Flbf = -int32(1) } return X__stdio_write(tls, f, buf, len1) @@ -137321,7 +137321,7 @@ _9: if v11 < Int32FromInt32(0) { v11 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v10), Int32FromInt32(FUTEX_WAKE)|v12, v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), Int32FromInt32(FUTEX_WAKE), v11) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)|v12), v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)), v11) != 0 } return c } @@ -137336,7 +137336,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 76) - if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid { + if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -137579,7 +137579,7 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var ploc uintptr var wc Twchar_t _, _, _ = loc, ploc, wc - ploc = ___get_tp(tls) + 88 + ploc = uintptr(___get_tp(tls)) + 88 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137730,7 +137730,7 @@ func Xflockfile(tls *TLS, f uintptr) { return } ___lockfile(tls, f) - X__register_locked_file(tls, f, ___get_tp(tls)) + X__register_locked_file(tls, f, uintptr(___get_tp(tls))) } type Tcookie = struct { @@ -137931,12 +137931,12 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { } /* Compute the flags to pass to open() */ flags = X__fmodeflags(tls, mode) - fd = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_open), int32(filename), flags|Int32FromInt32(O_LARGEFILE), Int32FromInt32(0666)))) + fd = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_open), int32(filename), int32(flags|Int32FromInt32(O_LARGEFILE)), int32(Int32FromInt32(0666))))) if fd < 0 { return uintptr(0) } if flags&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } f = X__fdopen(tls, fd, mode) if f != 0 { @@ -138182,7 +138182,7 @@ _10: if v12 < Int32FromInt32(0) { v12 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v11), Int32FromInt32(FUTEX_WAKE)|v13, v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), Int32FromInt32(FUTEX_WAKE), v12) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)|v13), v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)), v12) != 0 } return c } @@ -138199,7 +138199,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 76) - if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid { + if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid { if Int32FromUint8(Uint8FromInt32(v1)) != (*TFILE)(unsafe.Pointer(v2)).Flbf && (*TFILE)(unsafe.Pointer(v2)).Fwpos != (*TFILE)(unsafe.Pointer(v2)).Fwend { v6 = Uint8FromInt32(v1) v8 = v2 + 20 @@ -138251,7 +138251,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var v2 uint8 var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 - ploc = ___get_tp(tls) + 88 + ploc = uintptr(___get_tp(tls)) + 88 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -138343,7 +138343,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { var _ /* buf at bp+4 */ [1024]uint8 _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint32(0) - ploc = ___get_tp(tls) + 88 + ploc = uintptr(___get_tp(tls)) + 88 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -138483,10 +138483,10 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { Xfflush(tls, f) if !(filename != 0) { if fl&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) - if X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, Int32FromInt32(F_SETFL), fl))) < 0 { + if X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFL)), fl))) < 0 { goto fail } } else { @@ -138719,7 +138719,7 @@ func X__do_orphaned_stdio_locks(tls *TLS) { } var f uintptr _ = f - f = (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Fstdio_locks + f = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fstdio_locks for { if !(f != 0) { break @@ -138745,7 +138745,7 @@ func X__unlist_locked_file(tls *TLS, f uintptr) { if (*TFILE)(unsafe.Pointer(f)).Fprev_locked != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fprev_locked)).Fnext_locked = (*TFILE)(unsafe.Pointer(f)).Fnext_locked } else { - (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Fstdio_locks = (*TFILE)(unsafe.Pointer(f)).Fnext_locked + (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fstdio_locks = (*TFILE)(unsafe.Pointer(f)).Fnext_locked } } } @@ -138773,7 +138773,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { var v2 uintptr var v5 bool _, _, _, _, _, _, _, _ = old, owner, self, tid, v1, v2, v3, v5 - self = ___get_tp(tls) + self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 76) if owner & ^Int32FromInt32(MAYBE_WAITERS) == tid { @@ -138835,7 +138835,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale)) != 0) { + if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -139022,7 +139022,7 @@ _9: if v11 < Int32FromInt32(0) { v11 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v10), Int32FromInt32(FUTEX_WAKE)|v12, v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), Int32FromInt32(FUTEX_WAKE), v11) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)|v12), v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)), v11) != 0 } return c } @@ -139037,7 +139037,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 76) - if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid { + if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -139142,7 +139142,7 @@ _9: if v11 < Int32FromInt32(0) { v11 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v10), Int32FromInt32(FUTEX_WAKE)|v12, v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), Int32FromInt32(FUTEX_WAKE), v11) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)|v12), v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)), v11) != 0 } return c } @@ -139157,7 +139157,7 @@ func Xgetchar(tls *TLS) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = uintptr(unsafe.Pointer(&X__stdin_FILE)) l = AtomicLoadPInt32(v1 + 76) - if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid { + if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -139748,7 +139748,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { pid = (*TFILE)(unsafe.Pointer(f)).Fpipe_pid Xfclose(tls, f) for { - v1 = X__syscall4(tls, int32(SYS_wait4), pid, int32(bp), Int32FromInt32(0), Int32FromInt32(0)) + v1 = int32(X__syscall4(tls, int32(SYS_wait4), pid, int32(bp), int32(Int32FromInt32(0)), int32(Int32FromInt32(0)))) r = v1 if !(v1 == -int32(EINTR)) { break @@ -139854,7 +139854,7 @@ _10: if v12 < Int32FromInt32(0) { v12 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v11), Int32FromInt32(FUTEX_WAKE)|v13, v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), Int32FromInt32(FUTEX_WAKE), v12) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)|v13), v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)), v12) != 0 } return c } @@ -139871,7 +139871,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 76) - if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid { + if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid { if Int32FromUint8(Uint8FromInt32(v1)) != (*TFILE)(unsafe.Pointer(v2)).Flbf && (*TFILE)(unsafe.Pointer(v2)).Fwpos != (*TFILE)(unsafe.Pointer(v2)).Fwend { v6 = Uint8FromInt32(v1) v8 = v2 + 20 @@ -139984,7 +139984,7 @@ _10: if v12 < Int32FromInt32(0) { v12 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v11), Int32FromInt32(FUTEX_WAKE)|v13, v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), Int32FromInt32(FUTEX_WAKE), v12) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)|v13), v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)), v12) != 0 } return c } @@ -140001,7 +140001,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v1 = c1 v2 = uintptr(unsafe.Pointer(&X__stdout_FILE)) l = AtomicLoadPInt32(v2 + 76) - if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid { + if l < 0 || l != 0 && l & ^Int32FromInt32(MAYBE_WAITERS) == (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid { if Int32FromUint8(Uint8FromInt32(v1)) != (*TFILE)(unsafe.Pointer(v2)).Flbf && (*TFILE)(unsafe.Pointer(v2)).Fwpos != (*TFILE)(unsafe.Pointer(v2)).Fwend { v6 = Uint8FromInt32(v1) v8 = v2 + 20 @@ -140120,9 +140120,9 @@ func Xremove(tls *TLS, path uintptr) (r1 int32) { } var r int32 _ = r - r = X__syscall1(tls, int32(SYS_unlink), int32(path)) + r = int32(X__syscall1(tls, int32(SYS_unlink), int32(path))) if r == -int32(EISDIR) { - r = X__syscall1(tls, int32(SYS_rmdir), int32(path)) + r = int32(X__syscall1(tls, int32(SYS_rmdir), int32(path))) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -140393,7 +140393,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { } ___randname(tls, bp+1+uintptr(l)-uintptr(6)) *(*[1]uint8)(unsafe.Pointer(bp)) = [1]uint8{} - r = X__syscall3(tls, int32(SYS_readlink), int32(bp+1), int32(bp), Int32FromInt32(1)) + r = int32(X__syscall3(tls, int32(SYS_readlink), int32(bp+1), int32(bp), int32(Int32FromInt32(1)))) if r == -int32(ENOENT) { return Xstrdup(tls, bp+1) } @@ -140423,7 +140423,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { break } ___randname(tls, bp+uintptr(13)) - fd = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_open), int32(bp), Int32FromInt32(O_RDWR)|Int32FromInt32(O_CREAT)|Int32FromInt32(O_EXCL)|Int32FromInt32(O_LARGEFILE), Int32FromInt32(0600)))) + fd = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_open), int32(bp), int32(Int32FromInt32(O_RDWR)|Int32FromInt32(O_CREAT)|Int32FromInt32(O_EXCL)|Int32FromInt32(O_LARGEFILE)), int32(Int32FromInt32(0600))))) if fd >= 0 { X__syscall1(tls, int32(SYS_unlink), int32(bp)) f = X__fdopen(tls, fd, __ccgo_ts+1416) @@ -140459,7 +140459,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { } ___randname(tls, bp+1+uintptr(12)) *(*[1]uint8)(unsafe.Pointer(bp)) = [1]uint8{} - r = X__syscall3(tls, int32(SYS_readlink), int32(bp+1), int32(bp), Int32FromInt32(1)) + r = int32(X__syscall3(tls, int32(SYS_readlink), int32(bp+1), int32(bp), int32(Int32FromInt32(1)))) if r == -int32(ENOENT) { if buf != 0 { v2 = buf @@ -140528,7 +140528,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var v3 bool var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 - ploc = ___get_tp(tls) + 88 + ploc = uintptr(___get_tp(tls)) + 88 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -140803,7 +140803,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_LDBL): *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) } @@ -140992,7 +140992,7 @@ _4: } return v7 } - y = Xfrexpl(tls, y, bp+512) * Float64FromInt32(2) + y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { *(*int32)(unsafe.Pointer(bp + 512))-- } @@ -141055,7 +141055,7 @@ _4: v14 = s s++ *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) - y = Float64FromInt32(16) * (y - float64(x)) + y = float64(Float64FromInt32(16) * (y - float64(x))) if int32(s)-t__predefined_ptrdiff_t(bp+516) == int32(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -141108,7 +141108,7 @@ _4: *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) v21 = z z += 4 - y = Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21)))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) @@ -142978,7 +142978,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_LDBL): *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) } @@ -144555,7 +144555,7 @@ func Xatol(tls *TLS, s uintptr) (r int32) { for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s++ - n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - Int32FromUint8('0')) + n = int32(10)*n - int32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144808,7 +144808,7 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v11, v4 Tuint32_t var v14 bool _, _, _, _, _, _, _, _, _, _, _ = r, v1, v11, v12, v14, v2, v4, v5, v7, v8, v9 - v1 = *(*Tsize_t)(unsafe.Pointer(p)) - Uint32FromInt32(1) + v1 = uint32(*(*Tsize_t)(unsafe.Pointer(p)) - Uint32FromInt32(1)) v4 = v1 v5 = int32(31) - _a_clz_32(tls, v4&-v4) goto _6 @@ -148486,7 +148486,7 @@ func Xtcdrain(tls *TLS, fd int32) (r int32) { trc("tls=%v fd=%v, (%v:)", tls, fd, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ioctl), fd, Int32FromInt32(TCSBRK), Int32FromInt32(1), 0, 0, 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ioctl), fd, int32(Int32FromInt32(TCSBRK)), int32(Int32FromInt32(1)), 0, 0, 0))) } func Xtcflow(tls *TLS, fd int32, action int32) (r int32) { @@ -148541,7 +148541,7 @@ func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { trc("tls=%v fd=%v wsz=%v, (%v:)", tls, fd, wsz, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ioctl), fd, Int32FromInt32(TIOCGWINSZ), int32(wsz)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ioctl), fd, int32(Int32FromInt32(TIOCGWINSZ)), int32(wsz)))) } func Xtcsendbreak(tls *TLS, fd int32, dur int32) (r int32) { @@ -148574,7 +148574,7 @@ func Xtcsetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { trc("tls=%v fd=%v wsz=%v, (%v:)", tls, fd, wsz, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ioctl), fd, Int32FromInt32(TIOCSWINSZ), int32(wsz)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ioctl), fd, int32(Int32FromInt32(TIOCSWINSZ)), int32(wsz)))) } func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { @@ -148589,7 +148589,7 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { var _ /* st at bp+0 */ Tstat _, _, _ = fd, map1, v1 map1 = uintptr(-Int32FromInt32(1)) - fd = X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_open), int32(pathname), Int32FromInt32(O_RDONLY)|Int32FromInt32(O_CLOEXEC)|Int32FromInt32(O_NONBLOCK)|Int32FromInt32(O_LARGEFILE)))) + fd = X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_open), int32(pathname), int32(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_CLOEXEC)|Int32FromInt32(O_NONBLOCK)|Int32FromInt32(O_LARGEFILE))))) if fd < 0 { return uintptr(0) } @@ -149314,10 +149314,10 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp i = _scan_trans(tls, t, local, bp) if i != Uint32FromInt32(-Int32FromInt32(1)) { *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint32(6)*i+uint32(4))))) - *(*int32)(unsafe.Pointer(offset)) = Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)*i))) + *(*int32)(unsafe.Pointer(offset)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)*i)))) *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint32(6)*i+uint32(5))))) if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)**(*Tsize_t)(unsafe.Pointer(bp))))) + *(*int32)(unsafe.Pointer(oppoff)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -149542,7 +149542,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _, _ = id, ret id = Int32FromUint32(Uint32FromInt32(-pid-Int32FromInt32(1))*uint32(8) + uint32(2)) - ret = X__syscall2(tls, int32(SYS_clock_getres_time32), id, int32(bp)) + ret = int32(X__syscall2(tls, int32(SYS_clock_getres_time32), id, int32(bp))) if ret == -int32(EINVAL) { ret = -int32(ESRCH) } @@ -149565,7 +149565,7 @@ func Xclock_getres(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { _ = r /* On a 32-bit arch, use the old syscall if it exists. */ if int32(SYS_clock_getres_time32) != int32(SYS_clock_getres_time64) { - r = X__syscall2(tls, int32(SYS_clock_getres_time32), clk, int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_clock_getres_time32), clk, int32(bp))) if !(r != 0) && ts != 0 { (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp)))[0]) (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)] @@ -149589,14 +149589,14 @@ func X__clock_gettime(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint32(8) > uint32(4) { - r = X__syscall2(tls, int32(SYS_clock_gettime64), clk, int32(ts)) + r = int32(X__syscall2(tls, int32(SYS_clock_gettime64), clk, int32(ts))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } - r = X__syscall2(tls, int32(SYS_clock_gettime32), clk, int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_clock_gettime32), clk, int32(bp))) if r == -int32(ENOSYS) && clk == CLOCK_REALTIME { - r = X__syscall2(tls, int32(SYS_gettimeofday_time32), int32(bp), Int32FromInt32(0)) + r = int32(X__syscall2(tls, int32(SYS_gettimeofday_time32), int32(bp), int32(Int32FromInt32(0)))) *(*int32)(unsafe.Pointer(bp + 1*4)) *= int32(1000) } if !(r != 0) { @@ -149639,7 +149639,7 @@ func X__clock_nanosleep(tls *TLS, clk Tclockid_t, flags int32, req uintptr, rem 0: s, 1: int64(ns), } - r = ___syscall_cp(tls, int32(SYS_clock_nanosleep_time64), clk, flags, int32(bp), int32(rem), 0, 0) + r = int32(___syscall_cp(tls, int32(SYS_clock_nanosleep_time64), clk, flags, int32(bp), int32(rem), 0, 0)) } if Bool(false) || r != -int32(ENOSYS) { return -r @@ -149656,13 +149656,13 @@ func X__clock_nanosleep(tls *TLS, clk Tclockid_t, flags int32, req uintptr, rem v2 = uint64(0x7fffffff) + (0+Uint64FromInt64(s))>>int32(63) } *(*[2]int32)(unsafe.Pointer(bp + 16)) = [2]int32{ - 0: Int32FromUint64(v2), + 0: int32(Int32FromUint64(v2)), 1: ns, } if clk == CLOCK_REALTIME && !(flags != 0) { - r = ___syscall_cp(tls, int32(SYS_nanosleep), int32(bp+16), int32(bp+16), 0, 0, 0, 0) + r = int32(___syscall_cp(tls, int32(SYS_nanosleep), int32(bp+16), int32(bp+16), 0, 0, 0, 0)) } else { - r = ___syscall_cp(tls, int32(SYS_clock_nanosleep_time32), clk, flags, int32(bp+16), int32(bp+16), 0, 0) + r = int32(___syscall_cp(tls, int32(SYS_clock_nanosleep_time32), clk, flags, int32(bp+16), int32(bp+16), 0, 0)) } if r == -int32(EINTR) && rem != 0 && !(flags&Int32FromInt32(TIMER_ABSTIME) != 0) { (*Ttimespec)(unsafe.Pointer(rem)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp + 16)))[0]) + extra @@ -149697,7 +149697,7 @@ func Xclock_settime(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { 0: s, 1: int64(ns), } - r = X__syscall2(tls, int32(SYS_clock_settime64), clk, int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_clock_settime64), clk, int32(bp))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -150439,7 +150439,7 @@ func Xstrftime(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr) (r Tsize_t trc("tls=%v s=%v n=%v f=%v tm=%v, (%v:)", tls, s, n, f, tm, origin(2)) defer func() { trc("-> %v", r) }() } - return X__strftime_l(tls, s, n, f, tm, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__strftime_l(tls, s, n, f, tm, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } func Xstrftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tlocale_t) (r Tsize_t) { @@ -150939,10 +150939,10 @@ func Xtimer_delete(tls *TLS, t Ttimer_t) (r int32) { _a_barrier(tls) AtomicStorePInt32(td+84, AtomicLoadPInt32(td+84)|(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))) _a_barrier(tls) - X__syscall2(tls, int32(SYS_tkill), (*t__pthread)(unsafe.Pointer(td)).Ftid, Int32FromInt32(SIGTIMER)) + X__syscall2(tls, int32(SYS_tkill), (*t__pthread)(unsafe.Pointer(td)).Ftid, int32(Int32FromInt32(SIGTIMER))) return 0 } - return X__syscall1(tls, int32(SYS_timer_delete), int32(t)) + return int32(X__syscall1(tls, int32(SYS_timer_delete), int32(t))) } func Xtimer_getoverrun(tls *TLS, t Ttimer_t) (r int32) { @@ -150976,12 +150976,12 @@ func Xtimer_gettime(tls *TLS, t Ttimer_t, val uintptr) (r1 int32) { } r = -int32(ENOSYS) if uint32(8) > uint32(4) { - r = X__syscall2(tls, int32(SYS_timer_gettime64), int32(t), int32(val)) + r = int32(X__syscall2(tls, int32(SYS_timer_gettime64), int32(t), int32(val))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } - r = X__syscall2(tls, int32(SYS_timer_gettime32), int32(t), int32(bp)) + r = int32(X__syscall2(tls, int32(SYS_timer_gettime32), int32(t), int32(bp))) if !(r != 0) { (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)] @@ -151020,7 +151020,7 @@ func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) 2: vs, 3: int64(vns), } - r = X__syscall4(tls, int32(SYS_timer_settime64), int32(t), flags, int32(bp), int32(old)) + r = int32(X__syscall4(tls, int32(SYS_timer_settime64), int32(t), flags, int32(bp), int32(old))) } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -151034,7 +151034,7 @@ func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) 2: int32(vs), 3: vns, } - r = X__syscall4(tls, int32(SYS_timer_settime32), int32(t), flags, int32(bp+32), int32(bp+48)) + r = int32(X__syscall4(tls, int32(SYS_timer_settime32), int32(t), flags, int32(bp+32), int32(bp+48))) if !(r != 0) && old != 0 { (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[0]) (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(1)] @@ -151240,7 +151240,7 @@ func Xwcsftime(tls *TLS, wcs uintptr, n Tsize_t, f uintptr, tm uintptr) (r Tsize trc("tls=%v wcs=%v n=%v f=%v tm=%v, (%v:)", tls, wcs, n, f, tm, origin(2)) defer func() { trc("-> %v", r) }() } - return X__wcsftime_l(tls, wcs, n, f, tm, (*t__pthread)(unsafe.Pointer(___get_tp(tls))).Flocale) + return X__wcsftime_l(tls, wcs, n, f, tm, (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale) } func Xwcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tlocale_t) (r Tsize_t) { @@ -151321,7 +151321,7 @@ func Xclose(tls *TLS, fd int32) (r1 int32) { var r int32 _ = r fd = _dummy12(tls, fd) - r = ___syscall_cp(tls, int32(SYS_close), fd, 0, 0, 0, 0, 0) + r = int32(___syscall_cp(tls, int32(SYS_close), fd, 0, 0, 0, 0, 0)) if r == -int32(EINTR) { r = 0 } @@ -151359,7 +151359,7 @@ func Xdup2(tls *TLS, old int32, new1 int32) (r1 int32) { var r, v1 int32 _, _ = r, v1 for { - v1 = X__syscall2(tls, int32(SYS_dup2), old, new1) + v1 = int32(X__syscall2(tls, int32(SYS_dup2), old, new1)) r = v1 if !(v1 == -int32(EBUSY)) { break @@ -151380,7 +151380,7 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } if flags != 0 { for { - v1 = X__syscall3(tls, int32(SYS_dup3), old, new1, flags) + v1 = int32(X__syscall3(tls, int32(SYS_dup3), old, new1, flags)) r = v1 if !(v1 == -int32(EBUSY)) { break @@ -151394,14 +151394,14 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } } for { - v2 = X__syscall2(tls, int32(SYS_dup2), old, new1) + v2 = int32(X__syscall2(tls, int32(SYS_dup2), old, new1)) r = v2 if !(v2 == -int32(EBUSY)) { break } } if r >= 0 && flags&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), new1, Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), new1, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -151428,10 +151428,10 @@ func _checker(tls *TLS, p uintptr) (r int32) { var _ /* ret at bp+0 */ int32 _ = c c = p - if X__syscall2(tls, int32(SYS_setregid32), X__syscall0(tls, int32(SYS_getegid32)), -Int32FromInt32(1)) != 0 || X__syscall2(tls, int32(SYS_setreuid32), X__syscall0(tls, int32(SYS_geteuid32)), -Int32FromInt32(1)) != 0 { - X__syscall1(tls, int32(SYS_exit), Int32FromInt32(1)) + if X__syscall2(tls, int32(SYS_setregid32), X__syscall0(tls, int32(SYS_getegid32)), int32(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int32(SYS_setreuid32), X__syscall0(tls, int32(SYS_geteuid32)), int32(-Int32FromInt32(1))) != 0 { + X__syscall1(tls, int32(SYS_exit), int32(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = X__syscall4(tls, int32(SYS_faccessat), (*Tctx1)(unsafe.Pointer(c)).Ffd, int32((*Tctx1)(unsafe.Pointer(c)).Ffilename), (*Tctx1)(unsafe.Pointer(c)).Famode, Int32FromInt32(0)) + *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int32(SYS_faccessat), (*Tctx1)(unsafe.Pointer(c)).Ffd, int32((*Tctx1)(unsafe.Pointer(c)).Ffilename), (*Tctx1)(unsafe.Pointer(c)).Famode, int32(Int32FromInt32(0)))) X__syscall3(tls, int32(SYS_write), (*Tctx1)(unsafe.Pointer(c)).Fp, int32(bp), Int32FromUint32(Uint32FromInt64(4))) return 0 } @@ -151444,7 +151444,7 @@ func Xfaccessat(tls *TLS, fd int32, filename uintptr, amode int32, flag int32) ( var ret int32 _ = ret if flag != 0 { - ret = X__syscall4(tls, int32(SYS_faccessat2), fd, int32(filename), amode, flag) + ret = int32(X__syscall4(tls, int32(SYS_faccessat2), fd, int32(filename), amode, flag)) if ret != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(ret)) } @@ -151465,8 +151465,8 @@ func Xfchdir(tls *TLS, fd int32) (r int32) { var ret int32 var _ /* buf at bp+0 */ [27]uint8 _ = ret - ret = X__syscall1(tls, int32(SYS_fchdir), fd) - if ret != -int32(EBADF) || X__syscall2(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_GETFD)) < 0 { + ret = int32(X__syscall1(tls, int32(SYS_fchdir), fd)) + if ret != -int32(EBADF) || X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFD))) < 0 { return X__syscall_ret(tls, Uint32FromInt32(ret)) } X__procfdname(tls, bp, Uint32FromInt32(fd)) @@ -151483,8 +151483,8 @@ func Xfchown(tls *TLS, fd int32, uid Tuid_t, gid Tgid_t) (r int32) { var ret int32 var _ /* buf at bp+0 */ [27]uint8 _ = ret - ret = X__syscall3(tls, int32(SYS_fchown32), fd, Int32FromUint32(uid), Int32FromUint32(gid)) - if ret != -int32(EBADF) || X__syscall2(tls, int32(SYS_fcntl64), fd, Int32FromInt32(F_GETFD)) < 0 { + ret = int32(X__syscall3(tls, int32(SYS_fchown32), fd, Int32FromUint32(uid), Int32FromUint32(gid))) + if ret != -int32(EBADF) || X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFD))) < 0 { return X__syscall_ret(tls, Uint32FromInt32(ret)) } X__procfdname(tls, bp, Uint32FromInt32(fd)) @@ -151520,7 +151520,7 @@ func Xftruncate(tls *TLS, fd int32, length Toff_t) (r int32) { trc("tls=%v fd=%v length=%v, (%v:)", tls, fd, length, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_ftruncate64), fd, Int32FromInt32(0), int32(length), int32(length>>Int32FromInt32(32))))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_ftruncate64), fd, int32(Int32FromInt32(0)), int32(length), int32(length>>Int32FromInt32(32))))) } func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { @@ -151674,7 +151674,7 @@ func Xgetpgrp(tls *TLS) (r Tpid_t) { trc("tls=%v, (%v:)", tls, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall1(tls, int32(SYS_getpgid), Int32FromInt32(0)) + return int32(X__syscall1(tls, int32(SYS_getpgid), int32(Int32FromInt32(0)))) } func Xgetpid(tls *TLS) (r Tpid_t) { @@ -151682,7 +151682,7 @@ func Xgetpid(tls *TLS) (r Tpid_t) { trc("tls=%v, (%v:)", tls, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall0(tls, int32(SYS_getpid)) + return int32(X__syscall0(tls, int32(SYS_getpid))) } func Xgetppid(tls *TLS) (r Tpid_t) { @@ -151690,7 +151690,7 @@ func Xgetppid(tls *TLS) (r Tpid_t) { trc("tls=%v, (%v:)", tls, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall0(tls, int32(SYS_getppid)) + return int32(X__syscall0(tls, int32(SYS_getppid))) } func Xgetsid(tls *TLS, pid Tpid_t) (r Tpid_t) { @@ -151719,7 +151719,7 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { var r uint32 var _ /* wsz at bp+0 */ Twinsize _ = r - r = Uint32FromInt32(X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ioctl), fd, Int32FromInt32(TIOCGWINSZ), int32(bp))))) + r = Uint32FromInt32(X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ioctl), fd, int32(Int32FromInt32(TIOCGWINSZ)), int32(bp))))) if r == uint32(0) { return int32(1) } @@ -151835,7 +151835,7 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { if !(flag != 0) { return Xpipe(tls, fd) } - ret = X__syscall2(tls, int32(SYS_pipe2), int32(fd), flag) + ret = int32(X__syscall2(tls, int32(SYS_pipe2), int32(fd), flag)) if ret != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(ret)) } @@ -151847,12 +151847,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), Int32FromInt32(F_SETFD), Int32FromInt32(FD_CLOEXEC)) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), Int32FromInt32(F_SETFL), Int32FromInt32(O_NONBLOCK)) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151870,7 +151870,7 @@ func Xpread(tls *TLS, fd int32, buf uintptr, size Tsize_t, ofs Toff_t) (r Tssize trc("tls=%v fd=%v buf=%v size=%v ofs=%v, (%v:)", tls, fd, buf, size, ofs, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pread64), fd, int32(buf), Int32FromUint32(size), Int32FromInt32(0), int32(ofs), int32(ofs>>Int32FromInt32(32))))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pread64), fd, int32(buf), Int32FromUint32(size), int32(Int32FromInt32(0)), int32(ofs), int32(ofs>>Int32FromInt32(32))))) } func Xpreadv(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t) (r Tssize_t) { @@ -151886,7 +151886,7 @@ func Xpwrite(tls *TLS, fd int32, buf uintptr, size Tsize_t, ofs Toff_t) (r Tssiz trc("tls=%v fd=%v buf=%v size=%v ofs=%v, (%v:)", tls, fd, buf, size, ofs, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pwrite64), fd, int32(buf), Int32FromUint32(size), Int32FromInt32(0), int32(ofs), int32(ofs>>Int32FromInt32(32))))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pwrite64), fd, int32(buf), Int32FromUint32(size), int32(Int32FromInt32(0)), int32(ofs), int32(ofs>>Int32FromInt32(32))))) } func Xpwritev(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t) (r Tssize_t) { @@ -151919,7 +151919,7 @@ func Xreadlink(tls *TLS, path uintptr, buf uintptr, bufsize Tsize_t) (r1 Tssize_ buf = bp bufsize = uint32(1) } - r = X__syscall3(tls, int32(SYS_readlink), int32(path), int32(buf), Int32FromUint32(bufsize)) + r = int32(X__syscall3(tls, int32(SYS_readlink), int32(path), int32(buf), Int32FromUint32(bufsize))) if buf == bp && r > 0 { r = 0 } @@ -151940,7 +151940,7 @@ func Xreadlinkat(tls *TLS, fd int32, path uintptr, buf uintptr, bufsize Tsize_t) buf = bp bufsize = uint32(1) } - r = X__syscall4(tls, int32(SYS_readlinkat), fd, int32(path), int32(buf), Int32FromUint32(bufsize)) + r = int32(X__syscall4(tls, int32(SYS_readlinkat), fd, int32(path), int32(buf), Int32FromUint32(bufsize))) if buf == bp && r > 0 { r = 0 } @@ -152027,14 +152027,14 @@ func _do_setxid(tls *TLS, p uintptr) { if (*Tctx2)(unsafe.Pointer(c)).Fret < 0 { return } - ret = X__syscall3(tls, (*Tctx2)(unsafe.Pointer(c)).Fnr, (*Tctx2)(unsafe.Pointer(c)).Fid, (*Tctx2)(unsafe.Pointer(c)).Feid, (*Tctx2)(unsafe.Pointer(c)).Fsid) + ret = int32(X__syscall3(tls, (*Tctx2)(unsafe.Pointer(c)).Fnr, (*Tctx2)(unsafe.Pointer(c)).Fid, (*Tctx2)(unsafe.Pointer(c)).Feid, (*Tctx2)(unsafe.Pointer(c)).Fsid)) if ret != 0 && !((*Tctx2)(unsafe.Pointer(c)).Fret != 0) { /* If one thread fails to set ids after another has already * succeeded, forcibly killing the process is the only safe * thing to do. State is inconsistent and dangerous. Use * SIGKILL because it is uncatchable. */ X__block_all_sigs(tls, uintptr(0)) - X__syscall2(tls, int32(SYS_kill), X__syscall0(tls, int32(SYS_getpid)), Int32FromInt32(SIGKILL)) + X__syscall2(tls, int32(SYS_kill), X__syscall0(tls, int32(SYS_getpid)), int32(Int32FromInt32(SIGKILL))) } (*Tctx2)(unsafe.Pointer(c)).Fret = ret } @@ -152138,7 +152138,7 @@ func Xtruncate(tls *TLS, path uintptr, length Toff_t) (r int32) { trc("tls=%v path=%v length=%v, (%v:)", tls, path, length, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_truncate64), int32(path), Int32FromInt32(0), int32(length), int32(length>>Int32FromInt32(32))))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_truncate64), int32(path), int32(Int32FromInt32(0)), int32(length), int32(length>>Int32FromInt32(32))))) } /* Support signed or unsigned plain-char */ @@ -153549,7 +153549,7 @@ var X__exp2f_data = Texp2f_data{ 2: float64(0.6931471806916203), }, Fshift: float64(6.755399441055744e+15), - Finvln2_scaled: Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)), + Finvln2_scaled: float64(Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS))), Fpoly_scaled: [3]float64{ 0: Float64FromFloat64(0.05550361559341535) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)), 1: Float64FromFloat64(0.2402284522445722) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)), @@ -153558,7 +153558,7 @@ var X__exp2f_data = Texp2f_data{ } var X__exp_data = Texp_data{ - Finvln2N: Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP_TABLE_BITS)), + Finvln2N: float64(Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP_TABLE_BITS))), Fshift: float64(6.755399441055744e+15), Fnegln2hiN: -Float64FromFloat64(0.005415212348111709), Fnegln2loN: -Float64FromFloat64(1.2864023111638346e-14), @@ -155676,12 +155676,12 @@ var X__pow_log_data = Tpow_log_data{ Fln2lo: float64(5.497923018708371e-14), Fpoly: [7]float64{ 0: -Float64FromFloat64(0.5), - 1: Float64FromFloat64(0.3333333333333339) * float64(-Int32FromInt32(2)), - 2: -Float64FromFloat64(0.25000000000000033) * float64(-Int32FromInt32(2)), - 3: Float64FromFloat64(0.1999999998830994) * Float64FromInt32(4), - 4: -Float64FromFloat64(0.16666666658719348) * Float64FromInt32(4), - 5: Float64FromFloat64(0.14286370355743763) * float64(-Int32FromInt32(8)), - 6: -Float64FromFloat64(0.12500519079594427) * float64(-Int32FromInt32(8)), + 1: float64(Float64FromFloat64(0.3333333333333339) * float64(-Int32FromInt32(2))), + 2: float64(-Float64FromFloat64(0.25000000000000033) * float64(-Int32FromInt32(2))), + 3: float64(Float64FromFloat64(0.1999999998830994) * Float64FromInt32(4)), + 4: float64(-Float64FromFloat64(0.16666666658719348) * Float64FromInt32(4)), + 5: float64(Float64FromFloat64(0.14286370355743763) * float64(-Int32FromInt32(8))), + 6: float64(-Float64FromFloat64(0.12500519079594427) * float64(-Int32FromInt32(8))), }, Ftab: [128]struct { F__ccgo_align [0]uint32 @@ -156337,75 +156337,75 @@ var X__powf_log2_data = Tpowf_log2_data{ }{ 0: { Finvc: float64(1.398907162146528), - Flogc: -Float64FromFloat64(0.48430022186289673) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.48430022186289673) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 1: { Finvc: float64(1.3403141896637998), - Flogc: -Float64FromFloat64(0.42257122959194704) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.42257122959194704) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 2: { Finvc: float64(1.286432210124115), - Flogc: -Float64FromFloat64(0.3633754347673556) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.3633754347673556) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 3: { Finvc: float64(1.2367150214269895), - Flogc: -Float64FromFloat64(0.30651309567405577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.30651309567405577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 4: { Finvc: float64(1.1906977166711752), - Flogc: -Float64FromFloat64(0.25180720160537634) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.25180720160537634) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 5: { Finvc: float64(1.1479821020556429), - Flogc: -Float64FromFloat64(0.19910014943794563) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.19910014943794563) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 6: { Finvc: float64(1.1082251448272158), - Flogc: -Float64FromFloat64(0.14825100623281615) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.14825100623281615) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 7: { Finvc: float64(1.0711297413057381), - Flogc: -Float64FromFloat64(0.09913323807318392) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.09913323807318392) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 8: { Finvc: float64(1.036437278977283), - Flogc: -Float64FromFloat64(0.051632812977629436) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.051632812977629436) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 9: { Finvc: float64(1), - Flogc: float64(0) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 10: { Finvc: float64(0.9492859795739057), - Flogc: float64(0.07508531937943004) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.07508531937943004) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 11: { Finvc: float64(0.8951049428609004), - Flogc: float64(0.15987125980713107) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.15987125980713107) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 12: { Finvc: float64(0.8476821620351103), - Flogc: float64(0.2384046664317681) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.2384046664317681) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 13: { Finvc: float64(0.8050314851692001), - Flogc: float64(0.31288288605863257) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.31288288605863257) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 14: { Finvc: float64(0.7664671008843108), - Flogc: float64(0.38370422656453185) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.38370422656453185) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 15: { Finvc: float64(0.731428603316328), - Flogc: float64(0.451211048935815) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.451211048935815) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, }, Fpoly: [5]float64{ - 0: float64(0.288457581109214) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 1: -Float64FromFloat64(0.36092606229713164) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 2: float64(0.480898481472577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 3: -Float64FromFloat64(0.7213474675006291) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 4: float64(1.4426950408774342) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + 0: float64(float64(0.288457581109214) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 1: float64(-Float64FromFloat64(0.36092606229713164) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 2: float64(float64(0.480898481472577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 3: float64(-Float64FromFloat64(0.7213474675006291) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 4: float64(float64(1.4426950408774342) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, } |