diff options
Diffstat (limited to 'vendor/modernc.org/libc')
33 files changed, 10088 insertions, 7809 deletions
diff --git a/vendor/modernc.org/libc/Makefile b/vendor/modernc.org/libc/Makefile index a2ff9dacb..59936c0d4 100644 --- a/vendor/modernc.org/libc/Makefile +++ b/vendor/modernc.org/libc/Makefile @@ -32,13 +32,12 @@ download: @if [ ! -f $(TAR) ]; then wget $(URL) ; fi edit: - @if [ -f "Session.vim" ]; then novim -S & else novim -p Makefile go.mod builder.json & fi + @if [ -f "Session.vim" ]; then gvim -S & else gvim -p Makefile go.mod builder.json & fi editor: gofmt -l -s -w *.go go test -c -o /dev/null - go install -v - go build -o /dev/null generator*.go + go build -o /dev/null -v generator*.go generate: download mkdir -p $(DIR) || true diff --git a/vendor/modernc.org/libc/README.md b/vendor/modernc.org/libc/README.md index f2e9f3189..9908cb46a 100644 --- a/vendor/modernc.org/libc/README.md +++ b/vendor/modernc.org/libc/README.md @@ -1,20 +1,9 @@ # libc -Package libc provides C-runtime services. Work in progress. +[](https://liberapay.com/jnml/donate) +[](https://liberapay.com/jnml/donate) +[](https://liberapay.com/jnml/donate) -This package is a continuation of the Crt package in modernc.org/crt/v3. +[](https://pkg.go.dev/modernc.org/libc) -Installation - - $ go get [-u] modernc.org/libc - -Documentation: [godoc.org/modernc.org/libc](http://godoc.org/modernc.org/libc) - -Building with `make` requires the following Go packages - -* github.com/golang/lint/golint -* github.com/mdempsky/maligned -* github.com/mdempsky/unconvert -* honnef.co/go/tools/cmd/unused -* honnef.co/go/tools/cmd/gosimple -* github.com/client9/misspell/cmd/misspell +Package libc is a partial reimplementation of C libc in pure Go. diff --git a/vendor/modernc.org/libc/build_all_targets.sh b/vendor/modernc.org/libc/build_all_targets.sh index f0b66aa00..dd7823069 100644 --- a/vendor/modernc.org/libc/build_all_targets.sh +++ b/vendor/modernc.org/libc/build_all_targets.sh @@ -8,15 +8,18 @@ do echo "GOOS=darwin GOARCH=arm64" GOOS=darwin GOARCH=arm64 go build -tags=$tag -v ./... GOOS=darwin GOARCH=arm64 go test -tags=$tag -c -o /dev/null - echo "GOOS=freebsd GOARCH=386" - GOOS=freebsd GOARCH=386 go build -tags=$tag -v ./... - GOOS=freebsd GOARCH=386 go test -tags=$tag -c -o /dev/null + #TODO echo "GOOS=freebsd GOARCH=386" + #TODO GOOS=freebsd GOARCH=386 go build -tags=$tag -v ./... + #TODO GOOS=freebsd GOARCH=386 go test -tags=$tag -c -o /dev/null echo "GOOS=freebsd GOARCH=amd64" GOOS=freebsd GOARCH=amd64 go build -tags=$tag -v ./... GOOS=freebsd GOARCH=amd64 go test -tags=$tag -c -o /dev/null - echo "GOOS=freebsd GOARCH=arm" - GOOS=freebsd GOARCH=arm go build -tags=$tag -v ./... - GOOS=freebsd GOARCH=arm go test -tags=$tag -c -o /dev/null + echo "GOOS=freebsd GOARCH=arm64" + GOOS=freebsd GOARCH=arm64 go build -tags=$tag -v ./... + GOOS=freebsd GOARCH=arm64 go test -tags=$tag -c -o /dev/null + #TODO echo "GOOS=freebsd GOARCH=arm" + #TODO GOOS=freebsd GOARCH=arm go build -tags=$tag -v ./... + #TODO GOOS=freebsd GOARCH=arm go test -tags=$tag -c -o /dev/null echo "GOOS=linux GOARCH=386" GOOS=linux GOARCH=386 go build -tags=$tag -v ./... GOOS=linux GOARCH=386 go test -tags=$tag -c -o /dev/null diff --git a/vendor/modernc.org/libc/ccgo_linux_386.go b/vendor/modernc.org/libc/ccgo_linux_386.go index e7ee5d865..d3ac8f649 100644 --- a/vendor/modernc.org/libc/ccgo_linux_386.go +++ b/vendor/modernc.org/libc/ccgo_linux_386.go @@ -601,8 +601,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)) } @@ -654,8 +654,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)) } @@ -858,8 +858,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{ @@ -889,7 +889,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{ @@ -979,7 +979,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 } @@ -994,17 +994,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 @@ -1031,7 +1031,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 } @@ -1046,17 +1046,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 @@ -1177,24 +1177,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 { @@ -1207,15 +1207,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)) } @@ -1233,7 +1233,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)) } @@ -1246,14 +1246,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)) } @@ -1268,7 +1268,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)) } @@ -1284,14 +1284,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)) } @@ -1307,8 +1307,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)) } @@ -1334,24 +1334,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 { @@ -1364,15 +1364,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)) } @@ -1381,48 +1381,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)) } @@ -1523,8 +1523,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)) } @@ -1603,8 +1603,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)) } @@ -1939,18 +1939,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 { @@ -1962,16 +1962,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)) } @@ -1988,7 +1988,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)) @@ -2023,7 +2023,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)) } @@ -2041,14 +2041,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)) } @@ -2064,8 +2064,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)) } @@ -2097,18 +2097,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 { @@ -2120,16 +2120,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)) } @@ -2137,7 +2137,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)) @@ -2159,27 +2159,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)) } @@ -2307,16 +2307,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)) @@ -2423,16 +2423,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)) @@ -2535,7 +2535,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, @@ -2552,7 +2552,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, @@ -2591,18 +2591,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)) @@ -2633,7 +2633,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, @@ -2650,7 +2650,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, @@ -2678,17 +2678,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)) @@ -7612,7 +7612,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 @@ -7665,7 +7665,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): @@ -14055,7 +14055,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) @@ -24627,10 +24627,10 @@ func Xwcwidth(tls *TLS, wc Twchar_t) (r int32) { return v1 } if Uint32FromInt32(wc)&uint32(0xfffeffff) < uint32(0xfffe) { - if Int32FromUint8(_table5[Int32FromUint8(_table5[wc>>int32(8)])*int32(32)+wc&int32(255)>>int32(3)])>>(wc&int32(7))&int32(1) != 0 { + if Int32FromUint8(_table5[int32(Int32FromUint8(_table5[wc>>int32(8)])*int32(32))+wc&int32(255)>>int32(3)])>>(wc&int32(7))&int32(1) != 0 { return 0 } - if Int32FromUint8(_wtable[Int32FromUint8(_wtable[wc>>int32(8)])*int32(32)+wc&int32(255)>>int32(3)])>>(wc&int32(7))&int32(1) != 0 { + if Int32FromUint8(_wtable[int32(Int32FromUint8(_wtable[wc>>int32(8)])*int32(32))+wc&int32(255)>>int32(3)])>>(wc&int32(7))&int32(1) != 0 { return int32(2) } return int32(1) @@ -24981,7 +24981,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 @@ -25148,7 +25148,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 @@ -25178,7 +25178,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) { @@ -25787,7 +25787,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) { @@ -25907,9 +25907,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)) @@ -25922,23 +25922,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)) } @@ -25972,9 +25972,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)) } @@ -25993,7 +25993,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) { @@ -26001,7 +26001,7 @@ func Xposix_fadvise(tls *TLS, fd int32, base Toff_t, len1 Toff_t, advice int32) trc("tls=%v fd=%v base=%v len1=%v advice=%v, (%v:)", tls, fd, base, len1, advice, origin(2)) defer func() { trc("-> %v", r) }() } - return -X__syscall6(tls, int32(SYS_fadvise64_64), fd, int32(base), int32(base>>Int32FromInt32(32)), int32(len1), int32(len1>>Int32FromInt32(32)), advice) + return int32(-X__syscall6(tls, int32(SYS_fadvise64_64), fd, int32(base), int32(base>>Int32FromInt32(32)), int32(len1), int32(len1>>Int32FromInt32(32)), advice)) } func Xposix_fallocate(tls *TLS, fd int32, base Toff_t, len1 Toff_t) (r int32) { @@ -26009,7 +26009,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 FE_ALL_EXCEPT = 63 @@ -26425,19 +26425,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 { @@ -26461,14 +26461,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 */ @@ -26622,7 +26622,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: ; @@ -26648,16 +26648,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)) } } } @@ -26799,10 +26799,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) } } @@ -26838,7 +26838,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 @@ -26867,15 +26867,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) { @@ -26900,7 +26900,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) @@ -27901,7 +27901,7 @@ func Xmsgctl(tls *TLS, q int32, cmd int32, buf uintptr) (r1 int32) { orig = buf buf = bp } - r = X__syscall6(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_msgctl), q, cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64), Int32FromInt32(0), int32(buf), Int32FromInt32(0)) + r = int32(X__syscall6(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_msgctl)), q, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(Int32FromInt32(0)), int32(buf), int32(Int32FromInt32(0)))) if r >= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig *(*Tmsqid_ds)(unsafe.Pointer(buf)) = *(*Tmsqid_ds)(unsafe.Pointer(bp)) @@ -27917,7 +27917,7 @@ func Xmsgget(tls *TLS, k Tkey_t, flag int32) (r int32) { trc("tls=%v k=%v flag=%v, (%v:)", tls, k, flag, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_msgget), k, flag))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_msgget)), k, flag))) } func Xmsgrcv(tls *TLS, q int32, m uintptr, len1 Tsize_t, type1 int32, flag int32) (r Tssize_t) { @@ -27931,7 +27931,7 @@ func Xmsgrcv(tls *TLS, q int32, m uintptr, len1 Tsize_t, type1 int32, flag int32 0: int32(m), 1: type1, } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_msgrcv), q, Int32FromUint32(len1), flag, int32(bp), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_msgrcv)), q, Int32FromUint32(len1), flag, int32(bp), 0))) } func Xmsgsnd(tls *TLS, q int32, m uintptr, len1 Tsize_t, flag int32) (r int32) { @@ -27939,7 +27939,7 @@ func Xmsgsnd(tls *TLS, q int32, m uintptr, len1 Tsize_t, flag int32) (r int32) { trc("tls=%v q=%v m=%v len1=%v flag=%v, (%v:)", tls, q, m, len1, flag, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_msgsnd), q, Int32FromUint32(len1), flag, int32(m), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_msgsnd)), q, Int32FromUint32(len1), flag, int32(m), 0))) } const GETALL = 13 @@ -28036,7 +28036,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 + 4 } - r = X__syscall5(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_semctl), id, num, cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64), int32(bp)) + r = int32(X__syscall5(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_semctl)), id, num, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(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 + 4)) @@ -28058,7 +28058,7 @@ func Xsemget(tls *TLS, key Tkey_t, n int32, fl int32) (r int32) { if n > int32(USHRT_MAX) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_semget), key, n, fl))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_semget)), key, n, fl))) } func Xsemop(tls *TLS, id int32, buf uintptr, n Tsize_t) (r int32) { @@ -28066,7 +28066,7 @@ func Xsemop(tls *TLS, id int32, buf uintptr, n Tsize_t) (r int32) { trc("tls=%v id=%v buf=%v n=%v, (%v:)", tls, id, buf, n, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_semop), id, Int32FromUint32(n), Int32FromInt32(0), int32(buf)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_semop)), id, Int32FromUint32(n), int32(Int32FromInt32(0)), int32(buf)))) } const NO_TIME32 = 0 @@ -28135,7 +28135,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)) @@ -28147,7 +28147,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 @@ -28155,7 +28155,7 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int v4 = uintptr(0) } ts = v4 - return X__syscall_ret(tls, Uint32FromInt32(X__syscall6(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_semtimedop), id, Int32FromUint32(n), Int32FromInt32(0), int32(buf), int32(ts)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall6(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_semtimedop)), id, Int32FromUint32(n), int32(Int32FromInt32(0)), int32(buf), int32(ts)))) } const SHMLBA = 4096 @@ -28240,7 +28240,7 @@ func Xshmat(tls *TLS, id int32, _addr uintptr, flag int32) (r uintptr) { var ret uint32 var v1 uintptr _, _ = ret, v1 - ret = Uint32FromInt32(X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_shmat), id, flag, int32(bp), int32(*(*uintptr)(unsafe.Pointer(bp))))))) + ret = Uint32FromInt32(X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_shmat)), id, flag, int32(bp), int32(*(*uintptr)(unsafe.Pointer(bp))))))) if ret > -Uint32FromInt32(SHMLBA) { v1 = uintptr(ret) } else { @@ -28265,7 +28265,7 @@ func Xshmctl(tls *TLS, id int32, cmd int32, buf uintptr) (r1 int32) { orig = buf buf = bp } - r = X__syscall6(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_shmctl), id, cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64), Int32FromInt32(0), int32(buf), Int32FromInt32(0)) + r = int32(X__syscall6(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_shmctl)), id, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(Int32FromInt32(0)), int32(buf), int32(Int32FromInt32(0)))) if r >= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig *(*Tshmid_ds)(unsafe.Pointer(buf)) = *(*Tshmid_ds)(unsafe.Pointer(bp)) @@ -28281,7 +28281,7 @@ func Xshmdt(tls *TLS, addr uintptr) (r int32) { trc("tls=%v addr=%v, (%v:)", tls, addr, origin(2)) defer func() { trc("-> %v", r) }() } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_shmdt), Int32FromInt32(0), Int32FromInt32(0), Int32FromInt32(0), int32(addr)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_shmdt)), int32(Int32FromInt32(0)), int32(Int32FromInt32(0)), int32(Int32FromInt32(0)), int32(addr)))) } func Xshmget(tls *TLS, key Tkey_t, size Tsize_t, flag int32) (r int32) { @@ -28292,7 +28292,7 @@ func Xshmget(tls *TLS, key Tkey_t, size Tsize_t, flag int32) (r int32) { if size > Uint32FromInt32(Int32FromInt32(INT32_MAX)) { size = Uint32FromUint32(0xffffffff) } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_ipc), Int32FromInt32(IPCOP_shmget), key, Int32FromUint32(size), flag))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_shmget)), key, Int32FromUint32(size), flag))) } type Tpasswd = struct { @@ -28587,7 +28587,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: ; @@ -29434,7 +29434,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) @@ -29489,9 +29489,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 @@ -29595,9 +29595,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)) } @@ -29617,9 +29617,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)) } @@ -29645,9 +29645,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)) } @@ -29844,7 +29844,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 @@ -29933,9 +29933,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)) } @@ -30299,7 +30299,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) { @@ -30890,7 +30890,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) { @@ -30909,7 +30909,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) { @@ -31056,17 +31056,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)) @@ -31090,7 +31090,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)) } @@ -31230,7 +31230,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)) @@ -31244,7 +31244,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)] @@ -31267,12 +31267,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)] @@ -31441,7 +31441,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)) { Xmemcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ @@ -31582,7 +31582,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) { @@ -32148,7 +32148,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_cats, old_errno, p1, plural, q, r, rem, rule, trans, v10, v11, v12, v14, v15, v17, v20, 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) { @@ -98794,7 +98794,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) + 96 + ploc = uintptr(___get_tp(tls)) + 96 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { return uint32(0) @@ -99828,7 +99828,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) { @@ -100546,7 +100546,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) { @@ -100712,7 +100712,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 } @@ -100787,7 +100787,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 @@ -100876,7 +100876,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 { @@ -100919,7 +100919,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 @@ -100960,7 +100960,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 @@ -101004,12 +101004,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 = Float64FromFloat64(0.5) * z + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = Tdouble_t(z*(_C1+Tdouble_t(z*(float64(_C2)+Tdouble_t(z*_C3))))) + Tdouble_t(Tdouble_t(w*w)*(float64(_C4)+Tdouble_t(z*(_C5+Tdouble_t(z*float64(_C6)))))) + hz = Tdouble_t(Float64FromFloat64(0.5) * z) w = Float64FromFloat64(1) - hz - return w + (Float64FromFloat64(1) - w - hz + (z*r - x*y)) + return float64(w + (Float64FromFloat64(1) - w - hz + (Tdouble_t(z*r) - Tdouble_t(x*y)))) } // C documentation @@ -101029,10 +101029,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(Float64FromFloat64(1) + z*_C0 + w*_C11 + w*z*r) + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = float64(_C21) + Tdouble_t(z*_C31) + return float32(Float64FromFloat64(1) + Tdouble_t(z*float64(_C0)) + Tdouble_t(w*_C11) + Tdouble_t(Tdouble_t(w*z)*r)) } // C documentation @@ -101057,7 +101057,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 @@ -101082,7 +101082,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: @@ -101384,14 +101384,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) } } @@ -101402,14 +101402,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 { @@ -101417,14 +101417,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) } } @@ -101436,22 +101436,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) + float64(_toint) - float64(_toint) n = int32(fn) - r = x - fn*_pio2_1 - w = fn * _pio2_1t /* 1st round, good to 85 bits */ + r = x - Tdouble_t(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 - Tdouble_t(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 - Tdouble_t(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) } } *(*float64)(unsafe.Pointer(y)) = r - w @@ -101460,17 +101460,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 } } @@ -101498,7 +101498,7 @@ _1: break } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = (z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * Float64FromFloat64(1.6777216e+07) + z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * Float64FromFloat64(1.6777216e+07)) goto _3 _3: ; @@ -101678,7 +101678,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: ; @@ -101702,8 +101702,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: @@ -101712,8 +101712,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 @@ -101806,7 +101806,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: ; @@ -101833,8 +101833,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) @@ -101849,7 +101849,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: @@ -101868,7 +101868,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: ; @@ -102059,19 +102059,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) + float64(_toint1) - float64(_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 @@ -102168,14 +102168,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 + Tdouble_t(z*(float64(_S3)+Tdouble_t(z*_S4))) + Tdouble_t(Tdouble_t(z*w)*(float64(_S5)+Tdouble_t(z*_S6))) + v = Tdouble_t(z * x) if iy == 0 { - return x + v*(_S1+z*r) + return x + Tdouble_t(v*(float64(_S1)+Tdouble_t(z*r))) } else { - return x - (z*(float64(0.5)*y-v*r) - y - v*_S1) + return x - (Tdouble_t(z*(Tdouble_t(float64(0.5)*y)-Tdouble_t(v*r))) - y - Tdouble_t(v*float64(_S1))) } return r1 } @@ -102197,11 +102197,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 = float64(_S31) + Tdouble_t(z*_S41) + s = Tdouble_t(z * x) + return float32(x + Tdouble_t(s*(float64(_S11)+Tdouble_t(z*_S21))) + Tdouble_t(Tdouble_t(s*w)*r)) } var _T = [13]float64{ @@ -102244,21 +102244,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)] + Tdouble_t(w*(_T[int32(3)]+Tdouble_t(w*(_T[int32(5)]+Tdouble_t(w*(_T[int32(7)]+Tdouble_t(w*(_T[int32(9)]+Tdouble_t(w*_T[int32(11)]))))))))) + v = Tdouble_t(z * (_T[int32(2)] + Tdouble_t(w*(_T[int32(4)]+Tdouble_t(w*(_T[int32(6)]+Tdouble_t(w*(_T[int32(8)]+Tdouble_t(w*(_T[int32(10)]+Tdouble_t(w*_T[int32(12)]))))))))))) + s = Tdouble_t(z * x) + r = y + Tdouble_t(z*(Tdouble_t(s*(r+v))+y)) + Tdouble_t(s*_T[0]) w = x + r if big != 0 { s = float64(int32(1) - int32(2)*odd) - v = s - Float64FromFloat64(2)*(x+(r-w*w/(w+s))) + v = s - Tdouble_t(Float64FromFloat64(2)*(x+(r-Tdouble_t(w*w)/(w+s)))) if sign != 0 { v1 = -v } else { @@ -102274,12 +102274,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) w0 = *(*float64)(unsafe.Pointer(&v2)) v = r - (w0 - x) /* w0+v = r+x */ - v3 = -Float64FromFloat64(1) / w + v3 = float64(-Float64FromFloat64(1)) / w a = v3 a0 = v3 v4 = *(*Tuint64_t)(unsafe.Pointer(&a0))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) a0 = *(*float64)(unsafe.Pointer(&v4)) - return a0 + a*(float64(1)+a0*w0+a0*v) + return a0 + Tdouble_t(a*(float64(1)+float64(a0*w0)+Tdouble_t(a0*v))) } // C documentation @@ -102301,7 +102301,7 @@ func X__tandf(tls *TLS, x float64, odd int32) (r1 float32) { } var r, s, t, u, w, z, v1 Tdouble_t _, _, _, _, _, _, _ = 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 @@ -102316,14 +102316,14 @@ 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)] + Tdouble_t(z*_T1[int32(5)]) + t = _T1[int32(2)] + Tdouble_t(z*_T1[int32(3)]) + w = Tdouble_t(z * z) + s = Tdouble_t(z * x) + u = _T1[0] + Tdouble_t(z*_T1[int32(1)]) + r = x + Tdouble_t(s*u) + Tdouble_t(Tdouble_t(s*w)*(t+Tdouble_t(w*r))) if odd != 0 { - v1 = -Float64FromFloat64(1) / r + v1 = float64(-Float64FromFloat64(1)) / r } else { v1 = r } @@ -102346,8 +102346,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 } @@ -102368,7 +102368,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) } @@ -102379,24 +102379,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 */ @@ -102409,8 +102409,8 @@ var _qS11 = float32(-Float64FromFloat64(0.7066296339)) func _R1(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = float64(z * (_pS01 + z*(_pS11+z*_pS21))) - q = float64(Float32FromFloat32(1) + z*_qS11) + p = Tfloat_t(z * (_pS01 + float32(z*(_pS11+float32(z*_pS21))))) + q = float64(Float32FromFloat32(1) + float32(z*_qS11)) return float32(p / q) } @@ -102428,7 +102428,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) } @@ -102439,24 +102439,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 @@ -102487,11 +102487,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) @@ -102525,11 +102525,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) @@ -102568,8 +102568,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 } @@ -102589,7 +102589,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) } @@ -102599,21 +102599,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 @@ -102632,8 +102632,8 @@ var _qS13 = float32(-Float64FromFloat64(0.7066296339)) func _R3(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = float64(z * (_pS03 + z*(_pS13+z*_pS23))) - q = float64(Float32FromFloat32(1) + z*_qS13) + p = Tfloat_t(z * (_pS03 + float32(z*(_pS13+float32(z*_pS23))))) + q = float64(Float32FromFloat32(1) + float32(z*_qS13)) return float32(p / q) } @@ -102650,7 +102650,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 */ } @@ -102659,12 +102659,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 } @@ -102708,11 +102708,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) { @@ -102721,7 +102721,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)) } } } @@ -102773,11 +102773,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) { @@ -102873,7 +102873,7 @@ func Xatan(tls *TLS, x3 float64) (r float64) { if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { return x3 } - z = _atanhi[int32(3)] + Float64FromFloat32(7.52316384526264e-37) + z = float64(_atanhi[int32(3)] + Float64FromFloat32(7.52316384526264e-37)) if sign != 0 { v3 = -z } else { @@ -102903,7 +102903,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)) @@ -102911,7 +102911,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 @@ -102919,15 +102919,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] + Tdouble_t(w*(_aT[int32(2)]+Tdouble_t(w*(_aT[int32(4)]+Tdouble_t(w*(_aT[int32(6)]+Tdouble_t(w*(_aT[int32(8)]+Tdouble_t(w*_aT[int32(10)]))))))))))) + s2 = Tdouble_t(w * (_aT[int32(1)] + Tdouble_t(w*(_aT[int32(3)]+Tdouble_t(w*(_aT[int32(5)]+Tdouble_t(w*(_aT[int32(7)]+Tdouble_t(w*_aT[int32(9)]))))))))) if id < 0 { - return x3 - x3*(s1+s2) + return x3 - Tdouble_t(x3*(s1+s2)) } - z = _atanhi[id] - (x3*(s1+s2) - _atanlo[id] - x3) + z = _atanhi[id] - (Tdouble_t(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { v4 = -z } else { @@ -103013,9 +103013,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 { @@ -103130,9 +103130,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 { @@ -103247,7 +103247,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) @@ -103264,7 +103264,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)) @@ -103272,7 +103272,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 @@ -103280,15 +103280,15 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } } /* end of argument reduction */ - z = float64(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 * (float64(_aT1[0]) + w*(float64(_aT1[int32(2)])+w*float64(_aT1[int32(4)]))) - s2 = w * (float64(_aT1[int32(1)]) + w*float64(_aT1[int32(3)])) + s1 = Tfloat_t(z * (float64(_aT1[0]) + Tfloat_t(w*(float64(_aT1[int32(2)])+Tfloat_t(w*float64(_aT1[int32(4)])))))) + s2 = Tfloat_t(w * (float64(_aT1[int32(1)]) + Tfloat_t(w*float64(_aT1[int32(3)])))) if id < 0 { - return float32(float64(x3) - float64(x3)*(s1+s2)) + return float32(float64(x3) - Tfloat_t(float64(x3)*(s1+s2))) } - z = float64(_atanhi1[id]) - (float64(x3)*(s1+s2) - float64(_atanlo1[id]) - float64(x3)) + z = float64(_atanhi1[id]) - (Tfloat_t(float64(x3)*(s1+s2)) - float64(_atanlo1[id]) - float64(x3)) if sign != 0 { v4 = -z } else { @@ -103345,11 +103345,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, float64(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 @@ -103395,22 +103395,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 = float32(y3 * y3) + y = float32(Tfloat_t(y3 * y3)) } else { if uint32(4) == uint32(8) { - y1 = float64(float32(y3 * y3)) + y1 = float64(float32(Tfloat_t(y3 * y3))) } else { - y2 = float64(float32(y3 * y3)) + y2 = float64(float32(Tfloat_t(y3 * y3))) } } } } else { /* |x| < 0.5, up to 1.7ulp error */ - y3 = float64(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float64FromInt32(2)*y3+Float64FromInt32(2)*y3*y3/(Float64FromInt32(1)-y3)))) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Tfloat_t(Float64FromInt32(2)*y3)+Tfloat_t(Tfloat_t(Float64FromInt32(2)*y3)*y3)/(Float64FromInt32(1)-y3)))) } } else { /* avoid overflow */ - y3 = float64(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))))) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))))) } if s != 0 { v1 = -y3 @@ -103491,7 +103491,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 @@ -103513,8 +103513,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 + Tdouble_t(r*(float64(_P1)+Tdouble_t(r*_P2))) + Tdouble_t(Tdouble_t(Tdouble_t(r*r)*r)*(float64(_P3)+Tdouble_t(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 @@ -103529,11 +103529,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 } @@ -103571,7 +103571,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 { @@ -103585,14 +103585,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) } @@ -103607,7 +103607,7 @@ func Xcbrtl(tls *TLS, x float64) (r float64) { const DBL_EPSILON5 = 2.220446049250313e-16 -var _toint2 = Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16) +var _toint2 = float64(Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16)) func Xceil(tls *TLS, x3 float64) (r float64) { if __ccgo_strace { @@ -103662,7 +103662,7 @@ func Xceil(tls *TLS, x3 float64) (r float64) { return v1 } if y3 < Float64FromInt32(0) { - return x3 + y3 + Float64FromInt32(1) + return float64(x3 + y3 + Float64FromInt32(1)) } return x3 + y3 } @@ -103849,7 +103849,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) @@ -103881,10 +103881,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 { @@ -104014,19 +104014,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 */ @@ -104076,12 +104076,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)) @@ -104175,10 +104175,10 @@ var _sb7 = -Float64FromFloat64(22.44095244658582) /* 0xC03670E2, 0x42712D62 */ 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))))) - return Float64FromInt32(1) - _erx - P/Q + s = float64(Xfabs(tls, x) - Float64FromInt32(1)) + P = float64(_pa0) + Tdouble_t(s*(_pa1+Tdouble_t(s*(float64(_pa2)+Tdouble_t(s*(_pa3+Tdouble_t(s*(float64(_pa4)+Tdouble_t(s*(_pa5+Tdouble_t(s*float64(_pa6)))))))))))) + Q = Float64FromInt32(1) + Tdouble_t(s*(_qa1+Tdouble_t(s*(_qa2+Tdouble_t(s*(_qa3+Tdouble_t(s*(_qa4+Tdouble_t(s*(_qa5+Tdouble_t(s*_qa6))))))))))) + return float64(Float64FromInt32(1)-_erx) - P/Q } func _erfc2(tls *TLS, ix Tuint32_t, x float64) (r float64) { @@ -104190,18 +104190,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 = float64(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 = Float64FromFloat64(1) + s*(_sa1+s*(_sa2+s*(_sa3+s*(_sa4+s*(_sa5+s*(_sa6+s*(_sa7+s*_sa8))))))) + R = float64(_ra0) + Tdouble_t(s*(float64(_ra1)+Tdouble_t(s*(float64(_ra2)+Tdouble_t(s*(float64(_ra3)+Tdouble_t(s*(float64(_ra4)+Tdouble_t(s*(float64(_ra5)+Tdouble_t(s*(float64(_ra6)+Tdouble_t(s*float64(_ra7)))))))))))))) + S = Float64FromFloat64(1) + Tdouble_t(s*(_sa1+Tdouble_t(s*(_sa2+Tdouble_t(s*(_sa3+Tdouble_t(s*(_sa4+Tdouble_t(s*(_sa5+Tdouble_t(s*(_sa6+Tdouble_t(s*(_sa7+Tdouble_t(s*float64(_sa8)))))))))))))))) } else { /* |x| > 1/.35 */ - R = _rb0 + s*(_rb1+s*(_rb2+s*(_rb3+s*(_rb4+s*(_rb5+s*_rb6))))) - S = Float64FromFloat64(1) + s*(_sb1+s*(_sb2+s*(_sb3+s*(_sb4+s*(_sb5+s*(_sb6+s*_sb7)))))) + R = float64(_rb0) + Tdouble_t(s*(float64(_rb1)+Tdouble_t(s*(float64(_rb2)+Tdouble_t(s*(float64(_rb3)+Tdouble_t(s*(float64(_rb4)+Tdouble_t(s*(float64(_rb5)+Tdouble_t(s*float64(_rb6)))))))))))) + S = Float64FromFloat64(1) + Tdouble_t(s*(_sb1+Tdouble_t(s*(_sb2+Tdouble_t(s*(_sb3+Tdouble_t(s*(_sb4+Tdouble_t(s*(_sb5+Tdouble_t(s*(_sb6+Tdouble_t(s*float64(_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, Tdouble_t((z-x)*(z+x))+R/S)) / x } func Xerf(tls *TLS, x float64) (r1 float64) { @@ -104223,13 +104223,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) @@ -104264,14 +104264,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 { @@ -104284,7 +104284,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 } @@ -104361,8 +104361,8 @@ func _erfc11(tls *TLS, x float32) (r float32) { var P, Q, s Tfloat_t _, _, _ = P, Q, s s = float64(Xfabsf(tls, x) - Float32FromInt32(1)) - P = float64(_pa01) + s*(float64(_pa11)+s*(float64(_pa21)+s*(float64(_pa31)+s*(float64(_pa41)+s*(float64(_pa51)+s*float64(_pa61)))))) - Q = Float64FromInt32(1) + s*(float64(_qa11)+s*(float64(_qa21)+s*(float64(_qa31)+s*(float64(_qa41)+s*(float64(_qa51)+s*float64(_qa61)))))) + P = float64(_pa01) + Tfloat_t(s*(float64(_pa11)+Tfloat_t(s*(float64(_pa21)+Tfloat_t(s*(float64(_pa31)+Tfloat_t(s*(float64(_pa41)+Tfloat_t(s*(float64(_pa51)+Tfloat_t(s*float64(_pa61)))))))))))) + Q = Float64FromInt32(1) + Tfloat_t(s*(float64(_qa11)+Tfloat_t(s*(float64(_qa21)+Tfloat_t(s*(float64(_qa31)+Tfloat_t(s*(float64(_qa41)+Tfloat_t(s*(float64(_qa51)+Tfloat_t(s*float64(_qa61)))))))))))) return float32(float64(Float32FromInt32(1)-_erx1) - P/Q) } @@ -104375,18 +104375,18 @@ func _erfc21(tls *TLS, ix Tuint32_t, x float32) (r float32) { return _erfc11(tls, x) } x = Xfabsf(tls, x) - s = float64(Float32FromInt32(1) / (x * x)) + s = float64(Float32FromInt32(1) / float32(x*x)) if ix < uint32(0x4036db6d) { /* |x| < 1/0.35 */ - R = float64(_ra01) + s*(float64(_ra11)+s*(float64(_ra21)+s*(float64(_ra31)+s*(float64(_ra41)+s*(float64(_ra51)+s*(float64(_ra61)+s*float64(_ra71))))))) - S = Float64FromFloat32(1) + s*(float64(_sa11)+s*(float64(_sa21)+s*(float64(_sa31)+s*(float64(_sa41)+s*(float64(_sa51)+s*(float64(_sa61)+s*(float64(_sa71)+s*float64(_sa81)))))))) + R = float64(_ra01) + Tfloat_t(s*(float64(_ra11)+Tfloat_t(s*(float64(_ra21)+Tfloat_t(s*(float64(_ra31)+Tfloat_t(s*(float64(_ra41)+Tfloat_t(s*(float64(_ra51)+Tfloat_t(s*(float64(_ra61)+Tfloat_t(s*float64(_ra71)))))))))))))) + S = Float64FromFloat32(1) + Tfloat_t(s*(float64(_sa11)+Tfloat_t(s*(float64(_sa21)+Tfloat_t(s*(float64(_sa31)+Tfloat_t(s*(float64(_sa41)+Tfloat_t(s*(float64(_sa51)+Tfloat_t(s*(float64(_sa61)+Tfloat_t(s*(float64(_sa71)+Tfloat_t(s*float64(_sa81)))))))))))))))) } else { /* |x| >= 1/0.35 */ - R = float64(_rb01) + s*(float64(_rb11)+s*(float64(_rb21)+s*(float64(_rb31)+s*(float64(_rb41)+s*(float64(_rb51)+s*float64(_rb61)))))) - S = Float64FromFloat32(1) + s*(float64(_sb11)+s*(float64(_sb21)+s*(float64(_sb31)+s*(float64(_sb41)+s*(float64(_sb51)+s*(float64(_sb61)+s*float64(_sb71))))))) + R = float64(_rb01) + Tfloat_t(s*(float64(_rb11)+Tfloat_t(s*(float64(_rb21)+Tfloat_t(s*(float64(_rb31)+Tfloat_t(s*(float64(_rb41)+Tfloat_t(s*(float64(_rb51)+Tfloat_t(s*float64(_rb61)))))))))))) + S = Float64FromFloat32(1) + Tfloat_t(s*(float64(_sb11)+Tfloat_t(s*(float64(_sb21)+Tfloat_t(s*(float64(_sb31)+Tfloat_t(s*(float64(_sb41)+Tfloat_t(s*(float64(_sb51)+Tfloat_t(s*(float64(_sb61)+Tfloat_t(s*float64(_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, float32(float64((z-x)*(z+x))+R/S)) / x + return float32(Xexpf(tls, float32(-z*z)-Float32FromFloat32(0.5625))*Xexpf(tls, float32(Tfloat_t((z-x)*(z+x))+R/S))) / x } func Xerff(tls *TLS, x float32) (r1 float32) { @@ -104408,13 +104408,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) @@ -104449,14 +104449,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 { @@ -104469,7 +104469,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 } @@ -104513,7 +104513,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 = Float64FromFloat64(5.486124068793689e+303) * (scale + scale*tmp) + y3 = Tdouble_t(Float64FromFloat64(5.486124068793689e+303) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -104523,9 +104523,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 < Float64FromFloat64(1) { - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = Float64FromFloat64(1) + y3 lo = Float64FromFloat64(1) - hi + y3 + lo y = hi + lo @@ -104542,9 +104542,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 = Float64FromFloat64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * y3) y = y3 v7 = y goto _8 @@ -104595,7 +104595,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 @@ -104605,7 +104605,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 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(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)) @@ -104615,17 +104615,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))+Tdouble_t(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))+Tdouble_t(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: @@ -104662,8 +104662,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) } @@ -104738,10 +104738,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{ @@ -104803,7 +104803,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 @@ -104813,9 +104813,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 < Float64FromFloat64(1) { - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = Float64FromFloat64(1) + y3 lo = Float64FromFloat64(1) - hi + y3 + lo y = hi + lo @@ -104832,9 +104832,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 = Float64FromFloat64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * y3) y = y3 v7 = y goto _8 @@ -104909,17 +104909,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))+Tdouble_t(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))+Tdouble_t(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: @@ -104987,11 +104987,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 = Tdouble_t(*(*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 = Tdouble_t(*(*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 @@ -105075,7 +105075,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. */ @@ -105092,11 +105092,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 = Tdouble_t(*(*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 = Tdouble_t(*(*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 @@ -105190,10 +105190,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 - Tdouble_t(t*_ln2_hi) /* t*ln2_hi is exact here */ + lo = Tdouble_t(t * _ln2_lo) } x3 = hi - lo c = hi - x3 - lo @@ -105216,42 +105216,42 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { } } /* x is now in primary range */ - hfx = float64(0.5) * x3 - hxs = x3 * hfx - r1 = Float64FromFloat64(1) + hxs*(_Q1+hxs*(_Q2+hxs*(_Q3+hxs*(_Q4+hxs*_Q5)))) - t = Float64FromFloat64(3) - r1*hfx - e = hxs * ((r1 - t) / (Float64FromFloat64(6) - x3*t)) + hfx = Tdouble_t(float64(0.5) * x3) + hxs = Tdouble_t(x3 * hfx) + r1 = Float64FromFloat64(1) + Tdouble_t(hxs*(float64(_Q1)+Tdouble_t(hxs*(_Q2+Tdouble_t(hxs*(float64(_Q3)+Tdouble_t(hxs*(_Q4+Tdouble_t(hxs*float64(_Q5)))))))))) + t = Float64FromFloat64(3) - Tdouble_t(r1*hfx) + e = Tdouble_t(hxs * ((r1 - t) / (Float64FromFloat64(6) - Tdouble_t(x3*t)))) if k == 0 { /* c is 0 */ - return x3 - (x3*e - hxs) + return x3 - (Tdouble_t(x3*e) - hxs) } - e = x3*(e-c) - c + e = Tdouble_t(x3*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return Float64FromFloat64(0.5)*(x3-e) - Float64FromFloat64(0.5) + return float64(Tdouble_t(Float64FromFloat64(0.5)*(x3-e)) - Float64FromFloat64(0.5)) } if k == int32(1) { if x3 < -Float64FromFloat64(0.25) { - return -Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5))) + return float64(float64(-Float64FromFloat64(2)) * (e - float64(x3+Float64FromFloat64(0.5)))) } - return Float64FromFloat64(1) + Float64FromFloat64(2)*(x3-e) + return float64(Float64FromFloat64(1) + Tdouble_t(Float64FromFloat64(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 + Float64FromFloat64(1) if k == int32(1024) { - y3 = y3 * Float64FromFloat64(2) * Float64FromFloat64(8.98846567431158e+307) + y3 = Tdouble_t(Tdouble_t(y3*Float64FromFloat64(2)) * Float64FromFloat64(8.98846567431158e+307)) } else { - y3 = y3 * twopk + y3 = Tdouble_t(y3 * twopk) } - return y3 - Float64FromFloat64(1) + return float64(y3 - Float64FromFloat64(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 + float64(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 } @@ -105325,10 +105325,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 = float64(k) - hi = float64(x3) - t*float64(_ln2_hi1) /* t*ln2_hi is exact here */ - lo = t * float64(_ln2_lo1) + hi = float64(x3) - Tfloat_t(t*float64(_ln2_hi1)) /* t*ln2_hi is exact here */ + lo = Tfloat_t(t * float64(_ln2_lo1)) } x3 = float32(hi - lo) c = hi - float64(x3) - lo @@ -105336,7 +105336,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) @@ -105351,42 +105351,42 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { } } /* x is now in primary range */ - hfx = float64(Float32FromFloat32(0.5) * x3) - hxs = float64(x3) * hfx - r1 = Float64FromFloat32(1) + hxs*(float64(_Q11)+hxs*float64(_Q21)) - t = Float64FromFloat32(3) - r1*hfx - e = hxs * ((r1 - t) / (Float64FromFloat32(6) - float64(x3)*t)) + hfx = Tfloat_t(Float32FromFloat32(0.5) * x3) + hxs = Tfloat_t(float64(x3) * hfx) + r1 = Float64FromFloat32(1) + Tfloat_t(hxs*(float64(_Q11)+Tfloat_t(hxs*float64(_Q21)))) + t = Float64FromFloat32(3) - Tfloat_t(r1*hfx) + e = Tfloat_t(hxs * ((r1 - t) / (Float64FromFloat32(6) - Tfloat_t(float64(x3)*t)))) if k == 0 { /* c is 0 */ - return float32(float64(x3) - (float64(x3)*e - hxs)) + return float32(float64(x3) - (Tfloat_t(float64(x3)*e) - hxs)) } - e = float64(x3)*(e-c) - c + e = Tfloat_t(float64(x3)*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return float32(Float64FromFloat32(0.5)*(float64(x3)-e) - Float64FromFloat32(0.5)) + return float32(Tfloat_t(Float64FromFloat32(0.5)*(float64(x3)-e)) - Float64FromFloat32(0.5)) } if k == int32(1) { if x3 < -Float32FromFloat32(0.25) { return float32(float64(-Float32FromFloat32(2)) * (e - float64(x3+Float32FromFloat32(0.5)))) } - return float32(Float64FromFloat32(1) + Float64FromFloat32(2)*(float64(x3)-e)) + return float32(Float64FromFloat32(1) + Tfloat_t(Float64FromFloat32(2)*(float64(x3)-e))) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) + k) << int32(23)) /* 2^k */ twopk = float64(*(*float32)(unsafe.Pointer(bp))) if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */ y3 = float64(x3) - e + Float64FromFloat32(1) if k == int32(128) { - y3 = y3 * Float64FromFloat32(2) * Float64FromFloat32(1.7014118346046923e+38) + y3 = Tfloat_t(Tfloat_t(y3*Float64FromFloat32(2)) * Float64FromFloat32(1.7014118346046923e+38)) } else { - y3 = y3 * twopk + y3 = Tfloat_t(y3 * twopk) } return float32(y3 - Float64FromFloat32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) - k) << int32(23)) /* 2^-k */ if k < int32(23) { - y3 = (float64(x3) - e + float64(Float32FromInt32(1)-*(*float32)(unsafe.Pointer(bp)))) * twopk + y3 = Tfloat_t((float64(x3) - e + float64(Float32FromInt32(1)-*(*float32)(unsafe.Pointer(bp)))) * twopk) } else { - y3 = (float64(x3) - (e + float64(*(*float32)(unsafe.Pointer(bp)))) + Float64FromInt32(1)) * twopk + y3 = Tfloat_t((float64(x3) - (e + float64(*(*float32)(unsafe.Pointer(bp)))) + Float64FromInt32(1)) * twopk) } return float32(y3) } @@ -105575,7 +105575,7 @@ _2: const DBL_EPSILON7 = 2.220446049250313e-16 -var _toint3 = Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16) +var _toint3 = float64(Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16)) func Xfloor(tls *TLS, x3 float64) (r float64) { if __ccgo_strace { @@ -105630,7 +105630,7 @@ func Xfloor(tls *TLS, x3 float64) (r float64) { return float64(v1) } if y3 > Float64FromInt32(0) { - return x3 + y3 - Float64FromInt32(1) + return float64(x3 + y3 - Float64FromInt32(1)) } return x3 + y3 } @@ -105732,7 +105732,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 { @@ -105788,11 +105788,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 } @@ -105887,7 +105887,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 @@ -105908,8 +105908,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 */ @@ -105919,11 +105919,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 */ @@ -106246,11 +106246,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 } @@ -106297,7 +106297,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 } @@ -106310,7 +106310,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 } @@ -106387,11 +106387,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 } @@ -106438,7 +106438,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 } @@ -106451,7 +106451,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 } @@ -106509,7 +106509,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 @@ -106564,9 +106564,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)) } @@ -106583,11 +106583,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 * float64(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) { @@ -106685,7 +106685,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) { @@ -106764,7 +106764,7 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { y *= Float32FromFloat32(1.2379400392853803e+27) } } - return float32(z * float64(Xsqrtf(tls, float32(float64(x)*float64(x)+float64(y)*float64(y))))) + return float32(z * float64(Xsqrtf(tls, float32(float64(float64(x)*float64(x))+float64(float64(y)*float64(y)))))) } func Xhypotl(tls *TLS, x float64, y float64) (r float64) { @@ -106957,8 +106957,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 @@ -106967,10 +106967,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 @@ -106998,7 +106998,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 */ @@ -107008,16 +107008,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 } @@ -107063,12 +107063,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 @@ -107169,10 +107169,10 @@ 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 = Float64FromFloat64(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)))))) - return Float64FromFloat64(1) + r/s + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + return float64(Float64FromFloat64(1) + r/s) } // C documentation @@ -107277,10 +107277,10 @@ 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 = Float64FromFloat64(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))))))) - return (-Float64FromFloat64(0.125) + r/s) / x + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + return (float64(-Float64FromFloat64(0.125)) + r/s) / x } var _invsqrtpi1 = float32(0.56418961287) /* 0x3f106ebb */ @@ -107301,8 +107301,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 @@ -107311,10 +107311,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 @@ -107341,7 +107341,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 */ @@ -107350,13 +107350,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 } @@ -107397,12 +107397,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 @@ -107502,9 +107502,9 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 4*4))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -107610,9 +107610,9 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) return float32((float64(-Float32FromFloat32(0.125)) + r/s) / float64(x)) } @@ -107639,8 +107639,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 @@ -107649,13 +107649,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 @@ -107685,21 +107685,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{ @@ -107745,10 +107745,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 @@ -107848,10 +107848,10 @@ 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 = Float64FromFloat64(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)))))) - return Float64FromFloat64(1) + r/s + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + return float64(Float64FromFloat64(1) + r/s) } /* For x >= 8, the asymptotic expansions of qone is @@ -107955,10 +107955,10 @@ 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 = Float64FromFloat64(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))))))) - return (Float64FromFloat64(0.375) + r/s) / x + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + return float64((Float64FromFloat64(0.375) + r/s) / x) } var _invsqrtpi3 = float32(0.56418961287) /* 0x3f106ebb */ @@ -107975,8 +107975,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 @@ -107985,13 +107985,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 @@ -108021,20 +108021,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{ @@ -108076,10 +108076,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 @@ -108179,9 +108179,9 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 4*4))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -108286,9 +108286,9 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) return float32((Float64FromFloat32(0.375) + r/s) / float64(x)) } @@ -108363,7 +108363,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) @@ -108374,7 +108374,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: @@ -108388,7 +108388,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) @@ -108407,16 +108407,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 } @@ -108426,7 +108426,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: ; @@ -108442,7 +108442,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 { @@ -108450,7 +108450,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: @@ -108464,7 +108464,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) { @@ -108481,9 +108481,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 } } } @@ -108565,7 +108565,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) @@ -108578,7 +108578,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 @@ -108638,7 +108638,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: @@ -108651,7 +108651,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) @@ -108669,16 +108669,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 } @@ -108688,7 +108688,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: ; @@ -108704,7 +108704,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 { @@ -108712,7 +108712,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: @@ -108726,7 +108726,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) { @@ -108743,9 +108743,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 } } } @@ -108808,7 +108808,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 @@ -108925,8 +108925,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 @@ -108973,7 +108973,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 { @@ -108993,7 +108993,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) { @@ -109007,7 +109007,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { i = 0 } else { if ix >= uint32(0x3FCDA661) { - y = x - (_tc - Float64FromFloat64(1)) + y = float64(x - (_tc - Float64FromFloat64(1))) i = int32(1) } else { y = x @@ -109031,31 +109031,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 - Float64FromFloat64(0.5)*y + z = Tdouble_t(y * y) + p1 = _a0 + Tdouble_t(z*(_a2+Tdouble_t(z*(_a4+Tdouble_t(z*(_a6+Tdouble_t(z*(_a8+Tdouble_t(z*_a10))))))))) + p2 = Tdouble_t(z * (_a1 + Tdouble_t(z*(_a3+Tdouble_t(z*(_a5+Tdouble_t(z*(_a7+Tdouble_t(z*(_a9+Tdouble_t(z*_a11))))))))))) + p = Tdouble_t(y*p1) + p2 + r += p - Tdouble_t(Float64FromFloat64(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)) - r += _tf + p + z = Tdouble_t(y * y) + w = Tdouble_t(z * y) + p1 = _t0 + Tdouble_t(w*(float64(_t3)+Tdouble_t(w*(_t6+Tdouble_t(w*(float64(_t9)+Tdouble_t(w*_t12))))))) /* parallel comp */ + p2 = float64(_t1) + Tdouble_t(w*(_t4+Tdouble_t(w*(float64(_t7)+Tdouble_t(w*(_t10+Tdouble_t(w*float64(_t13)))))))) + p3 = _t2 + Tdouble_t(w*(float64(_t5)+Tdouble_t(w*(_t8+Tdouble_t(w*(float64(_t11)+Tdouble_t(w*_t14))))))) + p = Tdouble_t(z*p1) - (float64(_tt) - Tdouble_t(w*(p2+Tdouble_t(y*p3)))) + r += float64(_tf) + p case int32(2): - p1 = y * (_u0 + y*(_u1+y*(_u2+y*(_u3+y*(_u4+y*_u5))))) - p2 = Float64FromFloat64(1) + y*(_v1+y*(_v2+y*(_v3+y*(_v4+y*_v5)))) - r += -Float64FromFloat64(0.5)*y + p1/p2 + p1 = Tdouble_t(y * (float64(_u0) + Tdouble_t(y*(_u1+Tdouble_t(y*(_u2+Tdouble_t(y*(_u3+Tdouble_t(y*(_u4+Tdouble_t(y*_u5))))))))))) + p2 = Float64FromFloat64(1) + Tdouble_t(y*(_v1+Tdouble_t(y*(_v2+Tdouble_t(y*(_v3+Tdouble_t(y*(_v4+Tdouble_t(y*_v5))))))))) + r += Tdouble_t(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 = Float64FromFloat64(1) + y*(_r1+y*(_r2+y*(_r3+y*(_r4+y*(_r5+y*_r6))))) - r = Float64FromFloat64(0.5)*y + p/q + p = Tdouble_t(y * (float64(_s0) + Tdouble_t(y*(_s1+Tdouble_t(y*(_s2+Tdouble_t(y*(_s3+Tdouble_t(y*(_s4+Tdouble_t(y*(_s5+Tdouble_t(y*_s6))))))))))))) + q = Float64FromFloat64(1) + Tdouble_t(y*(_r1+Tdouble_t(y*(_r2+Tdouble_t(y*(_r3+Tdouble_t(y*(_r4+Tdouble_t(y*(_r5+Tdouble_t(y*_r6))))))))))) + r = Tdouble_t(Float64FromFloat64(0.5)*y) + p/q z = Float64FromFloat64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): @@ -109079,11 +109079,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-Float64FromFloat64(0.5))*(t-Float64FromFloat64(1)) + w + y = Tdouble_t(z * z) + w = _w0 + Tdouble_t(z*(_w1+Tdouble_t(y*(float64(_w2)+Tdouble_t(y*(_w3+Tdouble_t(y*(float64(_w4)+Tdouble_t(y*(_w5+Tdouble_t(y*float64(_w6)))))))))))) + r = Tdouble_t(float64(x-Float64FromFloat64(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))) } } } @@ -109182,10 +109182,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 *= Float64FromFloat64(3.141592653589793) switch n { default: /* case 4: */ @@ -109230,7 +109230,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 { @@ -109250,7 +109250,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) { @@ -109288,31 +109288,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): @@ -109336,11 +109336,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))) } } } @@ -109475,17 +109475,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)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + Tdouble_t(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+Tdouble_t(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+Tdouble_t(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ - w = r * Float64FromFloat64(1.34217728e+08) + w = Tdouble_t(r * Float64FromFloat64(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(Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) y1 += lo y1 += hi y = y1 @@ -109507,7 +109507,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) } @@ -109530,25 +109530,25 @@ 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 { Fchi float64 Fclo float64 })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 2192 + uintptr(i)*16))).Fchi - (*(*struct { 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))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v10 = y goto _11 @@ -109595,7 +109595,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) @@ -109621,12 +109621,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 = Float64FromFloat64(0.5) * f * f + hfsq = Tdouble_t(Tdouble_t(Float64FromFloat64(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 + Tdouble_t(w*(_Lg4+Tdouble_t(w*_Lg6))))) + t2 = Tdouble_t(z * (_Lg1 + Tdouble_t(w*(_Lg3+Tdouble_t(w*(_Lg5+Tdouble_t(w*_Lg7))))))) R = t2 + t1 /* See log2.c for details. */ /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */ @@ -109634,12 +109634,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 @@ -109689,7 +109689,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) @@ -109716,19 +109716,19 @@ func Xlog10f(tls *TLS, x float32) (r float32) { x = *(*float32)(unsafe.Pointer(bp)) f = float64(x - Float32FromFloat32(1)) s = f / (Float64FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (float64(_Lg21) + w*float64(_Lg41)) - t2 = z * (float64(_Lg11) + w*float64(_Lg31)) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (float64(_Lg21) + Tfloat_t(w*float64(_Lg41)))) + t2 = Tfloat_t(z * (float64(_Lg11) + Tfloat_t(w*float64(_Lg31)))) R = t2 + t1 - hfsq = Float64FromFloat32(0.5) * f * f + hfsq = Tfloat_t(Tfloat_t(Float64FromFloat32(0.5)*f) * f) hi = f - hfsq *(*float32)(unsafe.Pointer(bp)) = float32(hi) *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0xfffff000) hi = float64(*(*float32)(unsafe.Pointer(bp))) - lo = f - hi - hfsq + s*(hfsq+R) + lo = f - hi - hfsq + Tfloat_t(s*(hfsq+R)) dk = float64(k) - return float32(dk*float64(_log10_2lo1) + (lo+hi)*float64(_ivln10lo1) + lo*float64(_ivln10hi1) + hi*float64(_ivln10hi1) + dk*float64(_log10_2hi1)) + return float32(Tfloat_t(dk*float64(_log10_2lo1)) + Tfloat_t((lo+hi)*float64(_ivln10lo1)) + Tfloat_t(lo*float64(_ivln10hi1)) + Tfloat_t(hi*float64(_ivln10hi1)) + Tfloat_t(dk*float64(_log10_2hi1))) } func Xlog10l(tls *TLS, x float64) (r float64) { @@ -109828,17 +109828,17 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { /* reduce u into [sqrt(2)/2, sqrt(2)] */ hu = hu&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hu)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff) - f = *(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1) + f = float64(*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } - hfsq = Float64FromFloat64(0.5) * f * f + hfsq = Tdouble_t(Tdouble_t(Float64FromFloat64(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 + Tdouble_t(w*(_Lg42+Tdouble_t(w*_Lg61))))) + t2 = Tdouble_t(z * (_Lg12 + Tdouble_t(w*(_Lg32+Tdouble_t(w*(_Lg51+Tdouble_t(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 */ @@ -109887,7 +109887,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) @@ -109931,14 +109931,14 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { f = float64(*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } s = f / (Float64FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (float64(_Lg23) + w*float64(_Lg43)) - t2 = z * (float64(_Lg13) + w*float64(_Lg33)) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (float64(_Lg23) + Tfloat_t(w*float64(_Lg43)))) + t2 = Tfloat_t(z * (float64(_Lg13) + Tfloat_t(w*float64(_Lg33)))) R = t2 + t1 - hfsq = Float64FromFloat32(0.5) * f * f + hfsq = Tfloat_t(Tfloat_t(Float64FromFloat32(0.5)*f) * f) dk = float64(k) - return float32(s*(hfsq+R) + (dk*float64(_ln2_lo3) + c) - hfsq + f + dk*float64(_ln2_hi3)) + return float32(Tfloat_t(s*(hfsq+R)) + (Tfloat_t(dk*float64(_ln2_lo3)) + c) - hfsq + f + Tfloat_t(dk*float64(_ln2_hi3))) } func Xlog1pl(tls *TLS, x float64) (r float64) { @@ -109992,15 +109992,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)) + Tdouble_t(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)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 += lo y = y1 v8 = y @@ -110021,7 +110021,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) } @@ -110043,31 +110043,31 @@ 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 { Fchi float64 Fclo float64 })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 1168 + uintptr(i)*16))).Fchi - (*(*struct { 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)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+Tdouble_t(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 @@ -110130,7 +110130,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)) } @@ -110152,14 +110152,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 = Tdouble_t(*(*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 = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = Tdouble_t(*(*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 @@ -110225,10 +110225,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)) } @@ -110251,10 +110251,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)) } @@ -110277,10 +110277,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)) } @@ -110324,7 +110324,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)) } @@ -110345,13 +110345,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 = Tdouble_t(*(*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 = Tdouble_t(*(*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 @@ -110709,12 +110709,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))) } } } @@ -110809,12 +110809,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)))) } } } @@ -110936,12 +110936,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)))) } } } @@ -111018,25 +111018,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 - Float64FromFloat64(1) - rlo = zlo * invc + rhi = Tdouble_t(zhi*invc) - Float64FromFloat64(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)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + Tdouble_t(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+Tdouble_t(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+Tdouble_t(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 @@ -111061,7 +111061,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 = Float64FromFloat64(5.486124068793689e+303) * (scale + scale*tmp) + y3 = Tdouble_t(Float64FromFloat64(5.486124068793689e+303) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -111072,13 +111072,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 = Float64FromFloat64(1) if y3 < Float64FromFloat64(0) { - one = -Float64FromFloat64(1) + one = float64(-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 @@ -111096,9 +111096,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 = Float64FromFloat64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * y3) y = y3 v8 = y goto _9 @@ -111143,7 +111143,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 @@ -111153,7 +111153,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). */ @@ -111165,17 +111165,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))+Tdouble_t(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))+Tdouble_t(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: @@ -111263,17 +111263,17 @@ 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 } /* Without the barrier some versions of clang hoist the 1/x2 and thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { - y = Float64FromInt32(1) / x2 + y = float64(Float64FromInt32(1) / x2) v8 = y goto _9 _9: @@ -111326,7 +111326,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) @@ -111340,8 +111340,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) } @@ -111402,16 +111402,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 = Tdouble_t(*(*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 = Tdouble_t(*(*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 = Tdouble_t(*(*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 } @@ -111441,11 +111441,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 = Tdouble_t(*(*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 = Tdouble_t(*(*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 @@ -111513,10 +111513,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 = float64(x1 * x1) + x2 = Tfloat_t(x1 * x1) if ix&uint32(0x80000000) != 0 && _checkint1(tls, iy) == int32(1) { x2 = -x2 } @@ -111547,22 +111547,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) } } @@ -111686,7 +111686,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 @@ -111784,7 +111784,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++ } @@ -111857,7 +111857,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 @@ -111955,7 +111955,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++ } @@ -111984,7 +111984,7 @@ func Xremquol(tls *TLS, x float64, y float64, quo uintptr) (r float64) { const DBL_EPSILON11 = 2.220446049250313e-16 -var _toint4 = Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16) +var _toint4 = float64(Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16)) func Xrint(tls *TLS, x float64) (r float64) { if __ccgo_strace { @@ -112091,7 +112091,7 @@ func Xrintl(tls *TLS, x float64) (r float64) { const DBL_EPSILON13 = 2.220446049250313e-16 -var _toint6 = Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16) +var _toint6 = float64(Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16)) func Xround(tls *TLS, x3 float64) (r float64) { if __ccgo_strace { @@ -112135,13 +112135,13 @@ func Xround(tls *TLS, x3 float64) (r float64) { y2 = x3 + _toint6 } } - return Float64FromInt32(0) * *(*float64)(unsafe.Pointer(bp)) + return float64(Float64FromInt32(0) * *(*float64)(unsafe.Pointer(bp))) } y3 = x3 + _toint6 - _toint6 - x3 if y3 > Float64FromFloat64(0.5) { y3 = y3 + x3 - Float64FromInt32(1) } else { - if y3 <= -Float64FromFloat64(0.5) { + if y3 <= float64(-Float64FromFloat64(0.5)) { y3 = y3 + x3 + Float64FromInt32(1) } else { y3 = y3 + x3 @@ -112199,7 +112199,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 = float64(x3) + _toint7 - _toint7 - float64(x3) if y3 > Float64FromFloat32(0.5) { @@ -112253,7 +112253,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)) @@ -112261,7 +112261,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 } @@ -112304,7 +112304,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)) @@ -112312,7 +112312,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 } @@ -112337,8 +112337,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) @@ -112352,8 +112352,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) @@ -112395,10 +112395,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) @@ -112407,7 +112407,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 } @@ -112437,10 +112437,10 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { } } else { if n < -int32(126) { - y *= float64(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 *= float64(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) @@ -112631,10 +112631,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 { @@ -112793,10 +112793,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 { @@ -112941,14 +112941,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 } @@ -112989,12 +112989,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 } @@ -113061,7 +113061,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) @@ -113211,7 +113211,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)) } @@ -113344,10 +113344,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 { @@ -113482,20 +113482,20 @@ func Xtanh(tls *TLS, x3 float64) (r float64) { if w > uint32(0x40340000) { /* |x| > 20 or nan */ /* note: this branch avoids raising overflow */ - t = Float64FromInt32(1) - Float64FromInt32(0)/x3 + t = float64(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 */ @@ -113556,23 +113556,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) @@ -113620,12 +113620,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 */ @@ -113721,8 +113721,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: ; @@ -113804,7 +113804,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) @@ -113828,17 +113828,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 / Tdouble_t(Tdouble_t(_sinpi(tls, absx)*absx)*r) dy = -dy z = -z } - r += dy * (_gmhalf + Float64FromFloat64(0.5)) * r / y3 - z = Xpow(tls, y3, Float64FromFloat64(0.5)*z) - y3 = r * z * z + r += Tdouble_t(Tdouble_t(dy*float64(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + z = Xpow(tls, y3, float64(Float64FromFloat64(0.5)*z)) + y3 = float64(Tdouble_t(r*z) * z) return y3 } @@ -113899,7 +113899,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 @@ -113990,7 +113990,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) { @@ -114900,7 +114900,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) @@ -114948,7 +114948,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)) { Xmemcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ @@ -115342,7 +115342,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 { @@ -115353,7 +115353,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 } @@ -115973,7 +115973,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 @@ -116247,7 +116247,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) { @@ -116272,7 +116272,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)) } @@ -116997,7 +116997,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) { @@ -117091,7 +117091,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) @@ -117292,13 +117292,13 @@ 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) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + *(*Twchar_t)(unsafe.Pointer(wc)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s))))) return Uint32FromInt32(1) } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { @@ -117463,7 +117463,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) @@ -117485,7 +117485,7 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts c = uint32(*(*uint8)(unsafe.Pointer(v5))) v6 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + *(*Twchar_t)(unsafe.Pointer(v6)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) wn-- goto _4 _4: @@ -117691,13 +117691,13 @@ 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) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + *(*Twchar_t)(unsafe.Pointer(wc)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s))))) return Int32FromInt32(1) } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { @@ -117761,7 +117761,7 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { *(*int8)(unsafe.Pointer(s)) = int8(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) @@ -117968,7 +117968,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) @@ -118006,15 +118006,15 @@ func Xaccept(tls *TLS, fd int32, addr uintptr, len1 uintptr) (r1 int32) { v4 = fd v5 = int32(addr) v6 = int32(len1) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -118076,14 +118076,14 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int v5 = int32(addr) v6 = int32(len1) v7 = flg - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -118124,10 +118124,10 @@ _11: 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 } @@ -118148,15 +118148,15 @@ func Xbind(tls *TLS, fd int32, addr uintptr, len1 Tsocklen_t) (r1 int32) { v4 = fd v5 = int32(addr) v6 = Int32FromUint32(len1) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -118203,15 +118203,15 @@ func Xconnect(tls *TLS, fd int32, addr uintptr, len1 Tsocklen_t) (r1 int32) { v4 = fd v5 = int32(addr) v6 = Int32FromUint32(len1) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -121423,15 +121423,15 @@ func Xgetpeername(tls *TLS, fd int32, addr uintptr, len1 uintptr) (r1 int32) { v4 = fd v5 = int32(addr) v6 = int32(len1) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -121562,15 +121562,15 @@ func Xgetsockname(tls *TLS, fd int32, addr uintptr, len1 uintptr) (r1 int32) { v4 = fd v5 = int32(addr) v6 = int32(len1) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -121621,13 +121621,13 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, v6 = optname v7 = int32(optval) v8 = int32(optlen) - v9 = Int32FromInt32(0) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -121686,13 +121686,13 @@ _11: v17 = optname v18 = int32(bp + 152) v19 = int32(bp + 48) - v20 = Int32FromInt32(0) + v20 = int32(Int32FromInt32(0)) if v14 != 0 { r = ___syscall_cp(tls, v12, v15, v16, v17, v18, v19, v20) } else { r = X__syscall6(tls, v12, v15, v16, v17, v18, v19, v20) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v21 = r goto _22 } @@ -121748,13 +121748,13 @@ _11: v28 = optname v29 = int32(optval) v30 = int32(optlen) - v31 = Int32FromInt32(0) + v31 = int32(Int32FromInt32(0)) if v25 != 0 { r = ___syscall_cp(tls, v23, v26, v27, v28, v29, v30, v31) } else { r = X__syscall6(tls, v23, v26, v27, v28, v29, v30, v31) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v32 = r goto _33 } @@ -121795,10 +121795,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) + 88 + return uintptr(___get_tp(tls)) + 88 } func Xherror(tls *TLS, msg uintptr) { @@ -122544,16 +122544,16 @@ func Xlisten(tls *TLS, fd int32, backlog int32) (r1 int32) { v3 = 0 v4 = fd v5 = backlog - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -123796,7 +123796,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) { @@ -124198,7 +124198,7 @@ func Xrecvfrom(tls *TLS, fd int32, buf uintptr, len1 Tsize_t, flags int32, addr } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -124265,7 +124265,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)) } @@ -124292,14 +124292,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) { @@ -124375,10 +124375,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 } @@ -124390,10 +124390,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) @@ -124421,15 +124421,15 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { v4 = fd v5 = int32(msg) v6 = flags - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -125483,15 +125483,15 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { v4 = fd v5 = int32(msg) v6 = flags - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -125546,7 +125546,7 @@ func Xsendto(tls *TLS, fd int32, buf uintptr, len1 Tsize_t, flags int32, addr ui } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -125619,13 +125619,13 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, v6 = optname v7 = int32(optval) v8 = Int32FromUint32(optlen) - v9 = Int32FromInt32(0) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -125686,7 +125686,7 @@ _11: } *(*[2]int32)(unsafe.Pointer(bp + 48)) = [2]int32{ 0: int32(s), - 1: Int32FromUint64(v12), + 1: int32(Int32FromUint64(v12)), } v13 = int32(SYS_setsockopt) v14 = int32(__SC_setsockopt) @@ -125696,13 +125696,13 @@ _11: v18 = optname v19 = int32(bp + 48) v20 = Int32FromUint32(Uint32FromInt32(2) * Uint32FromInt64(4)) - v21 = Int32FromInt32(0) + v21 = int32(Int32FromInt32(0)) if v15 != 0 { r = ___syscall_cp(tls, v13, v16, v17, v18, v19, v20, v21) } else { r = X__syscall6(tls, v13, v16, v17, v18, v19, v20, v21) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v22 = r goto _23 } @@ -125751,13 +125751,13 @@ _11: v29 = optname v30 = int32(optval) v31 = Int32FromUint32(optlen) - v32 = Int32FromInt32(0) + v32 = int32(Int32FromInt32(0)) if v26 != 0 { r = ___syscall_cp(tls, v24, v27, v28, v29, v30, v31, v32) } else { r = X__syscall6(tls, v24, v27, v28, v29, v30, v31, v32) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v33 = r goto _34 } @@ -125808,16 +125808,16 @@ func Xshutdown(tls *TLS, fd int32, how int32) (r1 int32) { v3 = 0 v4 = fd v5 = how - v6 = Int32FromInt32(0) - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v6 = int32(Int32FromInt32(0)) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -125878,15 +125878,15 @@ func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { v4 = domain v5 = type1 v6 = protocol - v7 = Int32FromInt32(0) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v7 = int32(Int32FromInt32(0)) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -125920,17 +125920,17 @@ _11: v13 = int32(__SC_socket) v14 = 0 v15 = domain - v16 = type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK)) + v16 = int32(type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK))) v17 = protocol - v18 = Int32FromInt32(0) - v19 = Int32FromInt32(0) - v20 = Int32FromInt32(0) + v18 = int32(Int32FromInt32(0)) + v19 = int32(Int32FromInt32(0)) + v20 = int32(Int32FromInt32(0)) if v14 != 0 { r = ___syscall_cp(tls, v12, v15, v16, v17, v18, v19, v20) } else { r = X__syscall6(tls, v12, v15, v16, v17, v18, v19, v20) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v21 = r goto _22 } @@ -125963,10 +125963,10 @@ _11: 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)) @@ -125989,14 +125989,14 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr v5 = type1 v6 = protocol v7 = int32(fd) - v8 = Int32FromInt32(0) - v9 = Int32FromInt32(0) + v8 = int32(Int32FromInt32(0)) + v9 = int32(Int32FromInt32(0)) if v3 != 0 { r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v10 = r goto _11 } @@ -126030,17 +126030,17 @@ _11: v13 = int32(__SC_socketpair) v14 = 0 v15 = domain - v16 = type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK)) + v16 = int32(type1 & ^(Int32FromInt32(SOCK_CLOEXEC) | Int32FromInt32(SOCK_NONBLOCK))) v17 = protocol v18 = int32(fd) - v19 = Int32FromInt32(0) - v20 = Int32FromInt32(0) + v19 = int32(Int32FromInt32(0)) + v20 = int32(Int32FromInt32(0)) if v14 != 0 { r = ___syscall_cp(tls, v12, v15, v16, v17, v18, v19, v20) } else { r = X__syscall6(tls, v12, v15, v16, v17, v18, v19, v20) } - if r != -Int32FromInt32(ENOSYS) { + if r != int32(-Int32FromInt32(ENOSYS)) { v21 = r goto _22 } @@ -126073,12 +126073,12 @@ _11: 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 @@ -127641,7 +127641,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) { @@ -128154,7 +128154,7 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { var r int32 var _ /* buf at bp+0 */ [27]int8 _ = 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)) } @@ -128534,7 +128534,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) { @@ -128542,7 +128542,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 @@ -128715,7 +128715,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return 0 } if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if uint32(Uint32FromInt32(k))-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || uint32(Uint32FromInt32(kfold))-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { return BoolInt32(!(inv != 0)) } } @@ -128861,7 +128861,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } if v9 = Uint32FromInt8(*(*int8)(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) @@ -130409,8 +130409,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 { @@ -135079,7 +135079,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)) @@ -135099,7 +135099,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 @@ -135120,7 +135120,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 @@ -135145,7 +135145,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)) @@ -135228,9 +135228,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)) @@ -135267,21 +135267,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) { @@ -135295,7 +135295,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)]) @@ -135389,7 +135389,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 } @@ -135433,7 +135433,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)]) @@ -135513,7 +135513,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old 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) { @@ -135541,7 +135541,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) } else { v6 = uintptr(0) } - r = X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v5), int32(v6), Int32FromInt32(_NSIG)/Int32FromInt32(8)) + r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v5), int32(v6), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fhandler (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint32((*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fflags) @@ -135645,7 +135645,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)) @@ -135762,7 +135762,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)) @@ -135779,7 +135779,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) { @@ -135866,7 +135866,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 } @@ -135875,7 +135875,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) { @@ -135910,7 +135910,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 @@ -135922,14 +135922,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 } @@ -136003,8 +136003,8 @@ func Xfchmod(tls *TLS, fd int32, mode Tmode_t) (r int32) { var ret int32 var _ /* buf at bp+0 */ [27]int8 _ = 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)) @@ -136025,7 +136025,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)) } @@ -136038,7 +136038,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) { @@ -136052,7 +136052,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+144), Int32FromUint32(mode)))) + ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fchmodat), int32(-Int32FromInt32(100)), int32(bp+144), Int32FromUint32(mode)))) } } X__syscall1(tls, int32(SYS_close), fd2) @@ -136125,7 +136125,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 } @@ -136207,22 +136207,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 && !(*(*int8)(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+96, Uint32FromInt32(fd)) - ret = X__syscall2(tls, int32(SYS_stat64), int32(bp+96), int32(bp)) + ret = int32(X__syscall2(tls, int32(SYS_stat64), int32(bp+96), int32(bp))) } } } else { if (fd == -int32(100) || int32(*(*int8)(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) || int32(*(*int8)(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)) } } } @@ -136543,7 +136543,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)) @@ -136562,7 +136562,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)) } @@ -136588,11 +136588,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)) } @@ -136639,13 +136639,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 int32(*(*int8)(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) } @@ -136654,7 +136654,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. */ @@ -136717,11 +136717,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(136)) - (*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) @@ -136842,7 +136842,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)))) } @@ -136952,7 +136952,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) @@ -137486,7 +137486,7 @@ func _locking_getc(tls *TLS, f uintptr) (r int32) { if v5 < Int32FromInt32(0) { v5 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v4), Int32FromInt32(FUTEX_WAKE)|v6, v5) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v4), Int32FromInt32(FUTEX_WAKE), v5) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v4), int32(Int32FromInt32(FUTEX_WAKE)|v6), v5) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v4), int32(Int32FromInt32(FUTEX_WAKE)), v5) != 0 } return c } @@ -137501,7 +137501,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)) @@ -137744,7 +137744,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) + 96 + ploc = uintptr(___get_tp(tls)) + 96 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137895,7 +137895,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 { @@ -138094,12 +138094,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 { @@ -138325,7 +138325,7 @@ func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { if v6 < Int32FromInt32(0) { v6 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v5), Int32FromInt32(FUTEX_WAKE)|v7, v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), Int32FromInt32(FUTEX_WAKE), v6) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)|v7), v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)), v6) != 0 } return c } @@ -138342,7 +138342,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 @@ -138394,7 +138394,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var v2 uint8 var _ /* mbc at bp+0 */ [4]int8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 - ploc = ___get_tp(tls) + 96 + ploc = uintptr(___get_tp(tls)) + 96 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -138486,7 +138486,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) + 96 + ploc = uintptr(___get_tp(tls)) + 96 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -138626,10 +138626,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 { @@ -138862,7 +138862,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 @@ -138886,7 +138886,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 } } } @@ -138912,7 +138912,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { var owner, tid, v1 int32 var self Tpthread_t _, _, _, _ = owner, self, tid, v1 - 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 { @@ -138963,7 +138963,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) @@ -139132,7 +139132,7 @@ func _locking_getc1(tls *TLS, f uintptr) (r int32) { if v5 < Int32FromInt32(0) { v5 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v4), Int32FromInt32(FUTEX_WAKE)|v6, v5) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v4), Int32FromInt32(FUTEX_WAKE), v5) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v4), int32(Int32FromInt32(FUTEX_WAKE)|v6), v5) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v4), int32(Int32FromInt32(FUTEX_WAKE)), v5) != 0 } return c } @@ -139147,7 +139147,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)) @@ -139234,7 +139234,7 @@ func _locking_getc2(tls *TLS, f uintptr) (r int32) { if v5 < Int32FromInt32(0) { v5 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v4), Int32FromInt32(FUTEX_WAKE)|v6, v5) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v4), Int32FromInt32(FUTEX_WAKE), v5) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v4), int32(Int32FromInt32(FUTEX_WAKE)|v6), v5) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v4), int32(Int32FromInt32(FUTEX_WAKE)), v5) != 0 } return c } @@ -139249,7 +139249,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)) @@ -139837,7 +139837,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 @@ -139925,7 +139925,7 @@ func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { if v6 < Int32FromInt32(0) { v6 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v5), Int32FromInt32(FUTEX_WAKE)|v7, v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), Int32FromInt32(FUTEX_WAKE), v6) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)|v7), v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)), v6) != 0 } return c } @@ -139942,7 +139942,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 @@ -140037,7 +140037,7 @@ func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { if v6 < Int32FromInt32(0) { v6 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v5), Int32FromInt32(FUTEX_WAKE)|v7, v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), Int32FromInt32(FUTEX_WAKE), v6) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)|v7), v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)), v6) != 0 } return c } @@ -140054,7 +140054,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 @@ -140173,9 +140173,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)) } @@ -140446,7 +140446,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { } ___randname(tls, bp+1+uintptr(l)-uintptr(6)) *(*[1]int8)(unsafe.Pointer(bp)) = [1]int8{} - 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) } @@ -140476,7 +140476,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) @@ -140512,7 +140512,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { } ___randname(tls, bp+1+uintptr(12)) *(*[1]int8)(unsafe.Pointer(bp)) = [1]int8{} - 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 @@ -140581,7 +140581,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) + 96 + ploc = uintptr(___get_tp(tls)) + 96 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -140855,7 +140855,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))) } @@ -141043,7 +141043,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))-- } @@ -141106,7 +141106,7 @@ _4: v14 = s s++ *(*int8)(unsafe.Pointer(v14)) = int8(int32(_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++ @@ -141159,7 +141159,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) @@ -143029,7 +143029,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))) } @@ -144606,7 +144606,7 @@ func Xatol(tls *TLS, s uintptr) (r int32) { for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s++ - n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - Int32FromUint8('0')) + n = int32(10)*n - int32(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144858,7 +144858,7 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v1, v5 uint32 var v8 bool _, _, _, _, _, _, _ = r, v1, v2, v4, v5, v6, v8 - v1 = *(*Tsize_t)(unsafe.Pointer(p)) - Uint32FromInt32(1) + v1 = uint32(*(*Tsize_t)(unsafe.Pointer(p)) - Uint32FromInt32(1)) v2 = _a_ctz_32(tls, v1) goto _3 _3: @@ -148879,7 +148879,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) { @@ -148934,7 +148934,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) { @@ -148967,7 +148967,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) { @@ -148982,7 +148982,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) } @@ -149707,10 +149707,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 @@ -149935,7 +149935,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, Int32FromInt32(__NR_timer_create)+Int32FromInt32(7), id, int32(bp)) + ret = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(7)), id, int32(bp))) if ret == -int32(EINVAL) { ret = -int32(ESRCH) } @@ -149958,7 +149958,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 Int32FromInt32(__NR_timer_create)+Int32FromInt32(7) != int32(SYS_clock_getres_time64) { - r = X__syscall2(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(7), clk, int32(bp)) + r = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(7)), 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)] @@ -149967,7 +149967,7 @@ func Xclock_getres(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { } /* If reaching this point, it's a 64-bit arch or time64-only * 32-bit arch and we can get result directly into timespec. */ - return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(7), clk, int32(ts)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(7)), clk, int32(ts)))) } func X__clock_gettime(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { @@ -149982,14 +149982,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(Int32FromInt32(__NR_timer_create)+Int32FromInt32(6) == int32(SYS_clock_gettime64)) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } - r = X__syscall2(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(6), clk, int32(bp)) + r = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(6)), 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) { @@ -150032,7 +150032,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(Int32FromInt32(__NR_timer_create)+Int32FromInt32(8) == int32(SYS_clock_nanosleep_time64)) || r != -int32(ENOSYS) { return -r @@ -150049,13 +150049,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, Int32FromInt32(__NR_timer_create)+Int32FromInt32(8), clk, flags, int32(bp+16), int32(bp+16), 0, 0) + r = int32(___syscall_cp(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(8)), 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 @@ -150090,7 +150090,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(Int32FromInt32(__NR_timer_create)+Int32FromInt32(5) == int32(SYS_clock_settime64)) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -150102,7 +150102,7 @@ func Xclock_settime(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { 0: int32(s), 1: ns, } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(5), clk, int32(bp+16)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(5)), clk, int32(bp+16)))) } func Xctime(tls *TLS, t uintptr) (r uintptr) { @@ -150830,7 +150830,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) { @@ -151328,10 +151328,10 @@ func Xtimer_delete(tls *TLS, t Ttimer_t) (r int32) { if int32(t) < 0 { td = uintptr(uint32(t) << Int32FromInt32(1)) _a_store(tls, td+92, AtomicLoadPInt32(td+92)|(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))) - 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, Int32FromInt32(__NR_timer_create)+Int32FromInt32(4), int32(t)) + return int32(X__syscall1(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(4)), int32(t))) } func Xtimer_getoverrun(tls *TLS, t Ttimer_t) (r int32) { @@ -151345,7 +151345,7 @@ func Xtimer_getoverrun(tls *TLS, t Ttimer_t) (r int32) { td = uintptr(uint32(t) << Int32FromInt32(1)) t = uintptr(Uint32FromInt32(AtomicLoadPInt32(td+92) & Int32FromInt32(INT_MAX))) } - return X__syscall_ret(tls, Uint32FromInt32(X__syscall1(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(3), int32(t)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall1(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(3)), int32(t)))) } func Xtimer_gettime(tls *TLS, t Ttimer_t, val uintptr) (r1 int32) { @@ -151365,12 +151365,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(Int32FromInt32(__NR_timer_create)+Int32FromInt32(2) == int32(SYS_timer_gettime64)) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) } - r = X__syscall2(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(2), int32(t), int32(bp)) + r = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(2)), 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)] @@ -151378,7 +151378,7 @@ func Xtimer_gettime(tls *TLS, t Ttimer_t, val uintptr) (r1 int32) { (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) - return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(2), int32(t), int32(val)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(2)), int32(t), int32(val)))) } func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) (r1 int32) { @@ -151409,7 +151409,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(Int32FromInt32(__NR_timer_create)+Int32FromInt32(1) == int32(SYS_timer_settime64)) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -151423,7 +151423,7 @@ func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) 2: int32(vs), 3: vns, } - r = X__syscall4(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(1), int32(t), flags, int32(bp+32), int32(bp+48)) + r = int32(X__syscall4(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(1)), 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)] @@ -151431,7 +151431,7 @@ func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) - return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, Int32FromInt32(__NR_timer_create)+Int32FromInt32(1), int32(t), flags, int32(val), int32(old)))) + return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(1)), int32(t), flags, int32(val), int32(old)))) } type Ttms = struct { @@ -151628,7 +151628,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) { @@ -151709,7 +151709,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 } @@ -151747,7 +151747,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 @@ -151768,7 +151768,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 @@ -151782,14 +151782,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)) } @@ -151816,10 +151816,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 } @@ -151832,7 +151832,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)) } @@ -151853,8 +151853,8 @@ func Xfchdir(tls *TLS, fd int32) (r int32) { var ret int32 var _ /* buf at bp+0 */ [27]int8 _ = 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)) @@ -151871,8 +151871,8 @@ func Xfchown(tls *TLS, fd int32, uid Tuid_t, gid Tgid_t) (r int32) { var ret int32 var _ /* buf at bp+0 */ [27]int8 _ = 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)) @@ -152062,7 +152062,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) { @@ -152070,7 +152070,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) { @@ -152078,7 +152078,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) { @@ -152107,7 +152107,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) } @@ -152223,7 +152223,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)) } @@ -152235,12 +152235,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 } @@ -152307,7 +152307,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 } @@ -152328,7 +152328,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 } @@ -152415,14 +152415,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 } @@ -153937,7 +153937,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)), @@ -153946,7 +153946,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), @@ -156058,12 +156058,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 { Finvc float64 @@ -156717,75 +156717,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))), }, } diff --git a/vendor/modernc.org/libc/ccgo_linux_amd64.go b/vendor/modernc.org/libc/ccgo_linux_amd64.go index 84d299d51..15c013442 100644 --- a/vendor/modernc.org/libc/ccgo_linux_amd64.go +++ b/vendor/modernc.org/libc/ccgo_linux_amd64.go @@ -619,8 +619,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)) } @@ -672,8 +672,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)) } @@ -876,8 +876,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{ @@ -907,7 +907,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{ @@ -997,7 +997,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(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 } @@ -1012,17 +1012,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 @@ -1049,7 +1049,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(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 } @@ -1064,17 +1064,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 @@ -1195,24 +1195,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 { @@ -1225,15 +1225,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)) } @@ -1251,7 +1251,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)) } @@ -1264,14 +1264,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)) } @@ -1286,7 +1286,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)) } @@ -1302,14 +1302,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)) } @@ -1325,8 +1325,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)) } @@ -1352,24 +1352,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 { @@ -1382,15 +1382,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)) } @@ -1399,48 +1399,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)) } @@ -1541,8 +1541,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)) } @@ -1621,8 +1621,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)) } @@ -1957,18 +1957,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 { @@ -1980,16 +1980,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)) } @@ -2006,7 +2006,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)) @@ -2041,7 +2041,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)) } @@ -2059,14 +2059,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)) } @@ -2082,8 +2082,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)) } @@ -2115,18 +2115,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 { @@ -2138,16 +2138,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)) } @@ -2155,7 +2155,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)) @@ -2177,27 +2177,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)) } @@ -2325,16 +2325,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)) @@ -2441,16 +2441,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)) @@ -2553,7 +2553,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, @@ -2570,7 +2570,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, @@ -2609,18 +2609,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)) @@ -2651,7 +2651,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, @@ -2668,7 +2668,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, @@ -2696,17 +2696,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)) @@ -26305,19 +26305,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 { @@ -26341,14 +26341,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 */ @@ -26502,7 +26502,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: ; @@ -26528,16 +26528,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)) } } } @@ -26679,10 +26679,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) } } @@ -26718,7 +26718,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 @@ -26747,15 +26747,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) { @@ -26780,7 +26780,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) @@ -28336,7 +28336,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(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -100667,12 +100667,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 @@ -100692,10 +100692,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 @@ -100720,7 +100720,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 @@ -100745,7 +100745,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) { @@ -100943,7 +100943,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: @@ -100966,7 +100966,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: @@ -101047,14 +101047,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) } } @@ -101065,14 +101065,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 { @@ -101080,14 +101080,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) } } @@ -101099,22 +101099,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 @@ -101123,17 +101123,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 } } @@ -101161,7 +101161,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: ; @@ -101341,7 +101341,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: ; @@ -101365,8 +101365,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: @@ -101375,8 +101375,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 @@ -101469,7 +101469,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: ; @@ -101496,8 +101496,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) @@ -101512,7 +101512,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: @@ -101531,7 +101531,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: ; @@ -101722,19 +101722,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 @@ -101831,14 +101831,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 } @@ -101860,11 +101860,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{ @@ -101907,21 +101907,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 { @@ -101942,7 +101942,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 @@ -101965,7 +101965,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 @@ -101980,12 +101980,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 { @@ -102010,8 +102010,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 } @@ -102032,7 +102032,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) } @@ -102043,24 +102043,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 */ @@ -102073,8 +102073,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 } @@ -102092,7 +102092,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) } @@ -102103,24 +102103,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 @@ -102151,11 +102151,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) @@ -102189,11 +102189,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) @@ -102232,8 +102232,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 } @@ -102253,7 +102253,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) } @@ -102263,21 +102263,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 @@ -102296,8 +102296,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 } @@ -102314,7 +102314,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 */ } @@ -102323,12 +102323,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 } @@ -102372,11 +102372,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 uint64(8) == uint64(4) { @@ -102437,11 +102437,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 uint64(4) == uint64(4) { @@ -102567,7 +102567,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)) @@ -102575,7 +102575,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 @@ -102583,15 +102583,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 { @@ -102677,9 +102677,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 { @@ -102794,9 +102794,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 { @@ -102911,7 +102911,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -102928,7 +102928,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)) @@ -102936,7 +102936,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 @@ -102944,15 +102944,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 { @@ -103009,11 +103009,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 @@ -103059,22 +103059,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint64(4) == uint64(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 @@ -103156,7 +103156,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 @@ -103179,8 +103179,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 @@ -103195,11 +103195,11 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(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 } @@ -103237,7 +103237,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 { @@ -103251,14 +103251,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) } @@ -103551,10 +103551,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 { @@ -103690,13 +103690,13 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { 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 */ @@ -103746,12 +103746,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)) @@ -103846,8 +103846,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 } @@ -103860,18 +103860,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) { @@ -103893,13 +103893,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) @@ -103934,14 +103934,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 { @@ -103954,7 +103954,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 } @@ -104031,8 +104031,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 } @@ -104045,18 +104045,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) { @@ -104078,13 +104078,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) @@ -104119,14 +104119,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 { @@ -104139,7 +104139,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 } @@ -104183,7 +104183,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 = Tuint64_t(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 @@ -104193,9 +104193,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 = Tuint64_t(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 @@ -104212,9 +104212,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 @@ -104265,7 +104265,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 @@ -104275,7 +104275,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)) @@ -104285,17 +104285,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: @@ -104332,8 +104332,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) } @@ -104408,10 +104408,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{ @@ -104473,7 +104473,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 = Tuint64_t(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 @@ -104483,9 +104483,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 = Tuint64_t(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 @@ -104502,9 +104502,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 @@ -104579,17 +104579,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: @@ -104657,11 +104657,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 @@ -104745,7 +104745,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. */ @@ -104762,11 +104762,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 @@ -104860,10 +104860,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 @@ -104886,42 +104886,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 } @@ -104995,10 +104995,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 @@ -105006,7 +105006,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -105021,42 +105021,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 } @@ -105405,7 +105405,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 { @@ -105461,11 +105461,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 } @@ -105556,7 +105556,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 @@ -105577,8 +105577,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 */ @@ -105588,11 +105588,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 */ @@ -105916,11 +105916,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 } @@ -105969,7 +105969,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 } @@ -105982,7 +105982,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 } @@ -106059,11 +106059,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 } @@ -106110,7 +106110,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 } @@ -106123,7 +106123,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 } @@ -106182,7 +106182,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 @@ -106258,11 +106258,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) { @@ -106363,7 +106363,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) { @@ -106442,7 +106442,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) { @@ -106635,8 +106635,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 @@ -106645,10 +106645,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 @@ -106676,7 +106676,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 */ @@ -106686,16 +106686,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 } @@ -106741,12 +106741,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 @@ -106847,9 +106847,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 } @@ -106955,9 +106955,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 } @@ -106979,8 +106979,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 @@ -106989,10 +106989,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 @@ -107019,7 +107019,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 */ @@ -107028,13 +107028,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 } @@ -107075,12 +107075,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 @@ -107180,9 +107180,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 } @@ -107288,9 +107288,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 } @@ -107317,8 +107317,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 @@ -107327,13 +107327,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 @@ -107363,21 +107363,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{ @@ -107423,10 +107423,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 @@ -107526,9 +107526,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 } @@ -107633,9 +107633,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 } @@ -107653,8 +107653,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 @@ -107663,13 +107663,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 @@ -107699,20 +107699,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{ @@ -107754,10 +107754,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 @@ -107857,9 +107857,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 } @@ -107964,9 +107964,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 } @@ -108041,7 +108041,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) @@ -108052,7 +108052,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: @@ -108066,7 +108066,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) @@ -108085,16 +108085,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 } @@ -108104,7 +108104,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: ; @@ -108120,7 +108120,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 { @@ -108128,7 +108128,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: @@ -108142,7 +108142,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) { @@ -108159,9 +108159,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 } } } @@ -108243,7 +108243,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) @@ -108256,7 +108256,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 @@ -108316,7 +108316,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: @@ -108329,7 +108329,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) @@ -108347,16 +108347,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 } @@ -108366,7 +108366,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: ; @@ -108382,7 +108382,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 { @@ -108390,7 +108390,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: @@ -108404,7 +108404,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) { @@ -108421,9 +108421,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 } } } @@ -108486,7 +108486,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 @@ -108603,8 +108603,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 @@ -108651,7 +108651,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 { @@ -108671,7 +108671,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) { @@ -108709,31 +108709,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): @@ -108757,11 +108757,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))) } } } @@ -108860,10 +108860,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: */ @@ -108908,7 +108908,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 { @@ -108928,7 +108928,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) { @@ -108966,31 +108966,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): @@ -109014,11 +109014,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))) } } } @@ -109153,17 +109153,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 @@ -109185,7 +109185,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 = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } @@ -109208,25 +109208,25 @@ 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 { Fchi float64 Fclo float64 })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 2192 + uintptr(i)*16))).Fchi - (*(*struct { 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 @@ -109273,7 +109273,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) @@ -109299,12 +109299,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) */ @@ -109312,12 +109312,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 @@ -109367,7 +109367,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) @@ -109394,19 +109394,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) { @@ -109508,15 +109508,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 */ @@ -109565,7 +109565,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109609,14 +109609,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) { @@ -109670,15 +109670,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { v6 = uint64(*(*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 @@ -109699,7 +109699,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 = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } @@ -109721,31 +109721,31 @@ 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 { Fchi float64 Fclo float64 })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 1168 + uintptr(i)*16))).Fchi - (*(*struct { 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 = uint64(*(*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 @@ -109808,7 +109808,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)) } @@ -109830,14 +109830,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 @@ -109903,10 +109903,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)) } @@ -109929,10 +109929,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)) } @@ -109955,10 +109955,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)) } @@ -110002,7 +110002,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)) } @@ -110023,13 +110023,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 @@ -110357,12 +110357,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(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 uint64(8) == uint64(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))) } } } @@ -110457,12 +110457,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110584,12 +110584,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110666,25 +110666,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 @@ -110709,7 +110709,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 = Tuint64_t(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 @@ -110720,13 +110720,13 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl sbits = Tuint64_t(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 @@ -110744,9 +110744,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 @@ -110791,7 +110791,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 @@ -110801,7 +110801,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). */ @@ -110813,17 +110813,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: @@ -110911,10 +110911,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 } @@ -110974,7 +110974,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 = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) @@ -110988,8 +110988,8 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { v17 = uint64(*(*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) } @@ -111050,16 +111050,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 } @@ -111089,11 +111089,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 @@ -111161,10 +111161,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 } @@ -111195,22 +111195,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) } } @@ -111335,7 +111335,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 @@ -111435,7 +111435,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++ } @@ -111508,7 +111508,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 @@ -111606,7 +111606,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++ } @@ -111786,7 +111786,7 @@ func Xround(tls *TLS, x3 float64) (r float64) { 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) { @@ -111850,7 +111850,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) { @@ -111904,7 +111904,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)) @@ -111912,7 +111912,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 } @@ -111955,7 +111955,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)) @@ -111963,7 +111963,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 } @@ -112046,10 +112046,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) @@ -112058,7 +112058,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 } @@ -112088,10 +112088,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) @@ -112100,7 +112100,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 } @@ -112282,10 +112282,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 { @@ -112444,10 +112444,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 { @@ -112592,14 +112592,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 } @@ -112640,12 +112640,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 } @@ -112712,7 +112712,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) @@ -112862,7 +112862,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)) } @@ -112995,10 +112995,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 { @@ -113135,18 +113135,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 */ @@ -113207,23 +113207,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 uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113271,12 +113271,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 */ @@ -113372,8 +113372,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: ; @@ -113455,7 +113455,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) @@ -113479,17 +113479,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 } @@ -140176,7 +140176,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))-- } @@ -140239,7 +140239,7 @@ _4: v14 = s s++ *(*int8)(unsafe.Pointer(v14)) = int8(int32(_xdigits1[x]) | t&int32(32)) - y = Float64FromInt32(16) * (y - float64(x)) + y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -140292,7 +140292,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) @@ -151703,7 +151703,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)), @@ -151712,7 +151712,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), @@ -153824,12 +153824,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 { Finvc float64 @@ -154483,75 +154483,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))), }, } 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))), }, } diff --git a/vendor/modernc.org/libc/ccgo_linux_arm64.go b/vendor/modernc.org/libc/ccgo_linux_arm64.go index dd003c214..cd1f7cb31 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm64.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm64.go @@ -607,8 +607,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)) } @@ -660,8 +660,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)) } @@ -864,8 +864,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{ @@ -895,7 +895,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{ @@ -985,7 +985,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(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 } @@ -1000,17 +1000,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 @@ -1037,7 +1037,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(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 } @@ -1052,17 +1052,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 @@ -1183,24 +1183,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 { @@ -1213,15 +1213,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)) } @@ -1239,7 +1239,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)) } @@ -1252,14 +1252,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)) } @@ -1274,7 +1274,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)) } @@ -1290,14 +1290,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)) } @@ -1313,8 +1313,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)) } @@ -1340,24 +1340,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 { @@ -1370,15 +1370,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)) } @@ -1387,48 +1387,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)) } @@ -1529,8 +1529,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)) } @@ -1609,8 +1609,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)) } @@ -1945,18 +1945,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 { @@ -1968,16 +1968,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)) } @@ -1994,7 +1994,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)) @@ -2029,7 +2029,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)) } @@ -2047,14 +2047,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)) } @@ -2070,8 +2070,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)) } @@ -2103,18 +2103,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 { @@ -2126,16 +2126,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)) } @@ -2143,7 +2143,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)) @@ -2165,27 +2165,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)) } @@ -2313,16 +2313,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)) @@ -2429,16 +2429,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)) @@ -2541,7 +2541,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, @@ -2558,7 +2558,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, @@ -2597,18 +2597,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)) @@ -2639,7 +2639,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, @@ -2656,7 +2656,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, @@ -2684,17 +2684,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)) @@ -26219,19 +26219,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 { @@ -26255,14 +26255,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 */ @@ -26416,7 +26416,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: ; @@ -26442,16 +26442,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)) } } } @@ -26593,10 +26593,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) } } @@ -26632,7 +26632,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 @@ -26661,15 +26661,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) { @@ -26694,7 +26694,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) @@ -28246,7 +28246,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(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -100536,12 +100536,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 @@ -100561,10 +100561,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 @@ -100589,7 +100589,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 @@ -100614,7 +100614,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) { @@ -100812,7 +100812,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: @@ -100835,7 +100835,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: @@ -100916,14 +100916,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) } } @@ -100934,14 +100934,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 { @@ -100949,14 +100949,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) } } @@ -100968,22 +100968,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 @@ -100992,17 +100992,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 } } @@ -101030,7 +101030,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: ; @@ -101210,7 +101210,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: ; @@ -101234,8 +101234,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: @@ -101244,8 +101244,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 @@ -101338,7 +101338,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: ; @@ -101365,8 +101365,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) @@ -101381,7 +101381,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: @@ -101400,7 +101400,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: ; @@ -101591,19 +101591,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 @@ -101700,14 +101700,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 } @@ -101729,11 +101729,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{ @@ -101776,21 +101776,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 { @@ -101811,7 +101811,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 @@ -101834,7 +101834,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 @@ -101849,12 +101849,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 { @@ -101879,8 +101879,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 } @@ -101901,7 +101901,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) } @@ -101912,24 +101912,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 */ @@ -101942,8 +101942,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 } @@ -101961,7 +101961,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) } @@ -101972,24 +101972,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 @@ -102020,11 +102020,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) @@ -102058,11 +102058,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) @@ -102101,8 +102101,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 } @@ -102122,7 +102122,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) } @@ -102132,21 +102132,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 @@ -102165,8 +102165,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 } @@ -102183,7 +102183,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 */ } @@ -102192,12 +102192,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 } @@ -102241,11 +102241,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 uint64(8) == uint64(4) { @@ -102306,11 +102306,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 uint64(4) == uint64(4) { @@ -102436,7 +102436,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)) @@ -102444,7 +102444,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 @@ -102452,15 +102452,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 { @@ -102546,9 +102546,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 { @@ -102663,9 +102663,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 { @@ -102780,7 +102780,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -102797,7 +102797,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)) @@ -102805,7 +102805,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 @@ -102813,15 +102813,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 { @@ -102878,11 +102878,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 @@ -102928,22 +102928,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint64(4) == uint64(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 @@ -103025,7 +103025,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 @@ -103048,8 +103048,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 @@ -103064,11 +103064,11 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(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 } @@ -103106,7 +103106,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 { @@ -103120,14 +103120,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) } @@ -103420,10 +103420,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 { @@ -103559,13 +103559,13 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { 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 */ @@ -103615,12 +103615,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)) @@ -103715,8 +103715,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 } @@ -103729,18 +103729,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) { @@ -103762,13 +103762,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) @@ -103803,14 +103803,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 { @@ -103823,7 +103823,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 } @@ -103900,8 +103900,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 } @@ -103914,18 +103914,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) { @@ -103947,13 +103947,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) @@ -103988,14 +103988,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 { @@ -104008,7 +104008,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 } @@ -104052,7 +104052,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 = Tuint64_t(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 @@ -104062,9 +104062,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 = Tuint64_t(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 @@ -104081,9 +104081,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 @@ -104134,7 +104134,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 @@ -104144,7 +104144,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)) @@ -104154,17 +104154,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: @@ -104201,8 +104201,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) } @@ -104277,10 +104277,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{ @@ -104342,7 +104342,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 = Tuint64_t(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 @@ -104352,9 +104352,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 = Tuint64_t(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 @@ -104371,9 +104371,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 @@ -104448,17 +104448,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: @@ -104526,11 +104526,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 @@ -104614,7 +104614,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. */ @@ -104631,11 +104631,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 @@ -104729,10 +104729,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 @@ -104755,42 +104755,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 } @@ -104864,10 +104864,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 @@ -104875,7 +104875,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -104890,42 +104890,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 } @@ -105274,7 +105274,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 { @@ -105330,11 +105330,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 } @@ -105425,7 +105425,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 @@ -105446,8 +105446,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 */ @@ -105457,11 +105457,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 */ @@ -105785,11 +105785,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 } @@ -105838,7 +105838,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 } @@ -105851,7 +105851,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 } @@ -105928,11 +105928,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 } @@ -105979,7 +105979,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 } @@ -105992,7 +105992,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 } @@ -106051,7 +106051,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 @@ -106127,11 +106127,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) { @@ -106232,7 +106232,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) { @@ -106311,7 +106311,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) { @@ -106504,8 +106504,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 @@ -106514,10 +106514,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 @@ -106545,7 +106545,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 */ @@ -106555,16 +106555,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 } @@ -106610,12 +106610,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 @@ -106716,9 +106716,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 } @@ -106824,9 +106824,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 } @@ -106848,8 +106848,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 @@ -106858,10 +106858,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 @@ -106888,7 +106888,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 */ @@ -106897,13 +106897,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 } @@ -106944,12 +106944,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 @@ -107049,9 +107049,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 } @@ -107157,9 +107157,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 } @@ -107186,8 +107186,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 @@ -107196,13 +107196,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 @@ -107232,21 +107232,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{ @@ -107292,10 +107292,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 @@ -107395,9 +107395,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 } @@ -107502,9 +107502,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 } @@ -107522,8 +107522,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 @@ -107532,13 +107532,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 @@ -107568,20 +107568,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{ @@ -107623,10 +107623,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 @@ -107726,9 +107726,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 } @@ -107833,9 +107833,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 } @@ -107910,7 +107910,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) @@ -107921,7 +107921,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: @@ -107935,7 +107935,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) @@ -107954,16 +107954,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 } @@ -107973,7 +107973,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: ; @@ -107989,7 +107989,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 { @@ -107997,7 +107997,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: @@ -108011,7 +108011,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) { @@ -108028,9 +108028,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 } } } @@ -108112,7 +108112,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) @@ -108125,7 +108125,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 @@ -108185,7 +108185,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: @@ -108198,7 +108198,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) @@ -108216,16 +108216,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 } @@ -108235,7 +108235,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: ; @@ -108251,7 +108251,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 { @@ -108259,7 +108259,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: @@ -108273,7 +108273,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) { @@ -108290,9 +108290,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 } } } @@ -108355,7 +108355,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 @@ -108472,8 +108472,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 @@ -108520,7 +108520,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 { @@ -108540,7 +108540,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) { @@ -108578,31 +108578,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): @@ -108626,11 +108626,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))) } } } @@ -108729,10 +108729,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: */ @@ -108777,7 +108777,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 { @@ -108797,7 +108797,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) { @@ -108835,31 +108835,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): @@ -108883,11 +108883,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))) } } } @@ -109022,17 +109022,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 @@ -109054,7 +109054,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 = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } @@ -109080,16 +109080,16 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) 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 @@ -109136,7 +109136,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) @@ -109162,12 +109162,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) */ @@ -109175,12 +109175,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 @@ -109230,7 +109230,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) @@ -109257,19 +109257,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) { @@ -109371,15 +109371,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 */ @@ -109428,7 +109428,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109472,14 +109472,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) { @@ -109529,15 +109529,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - hi = r * X__log2_data.Finvln2hi - lo = r*X__log2_data.Finvln2lo + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(r * X__log2_data.Finvln2hi) + lo = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) + 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 v6 = y @@ -109558,7 +109558,7 @@ func Xlog2(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 = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } @@ -109583,20 +109583,20 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) - t1 = r * X__log2_data.Finvln2hi - t2 = r*X__log2_data.Finvln2lo + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) + t1 = Tdouble_t(r * X__log2_data.Finvln2hi) + t2 = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) /* 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 v10 = y goto _11 @@ -109655,7 +109655,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)) } @@ -109677,14 +109677,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 @@ -109746,10 +109746,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)) } @@ -109772,10 +109772,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)) } @@ -109798,10 +109798,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)) } @@ -109845,7 +109845,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)) } @@ -109866,13 +109866,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 @@ -110200,12 +110200,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(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 uint64(8) == uint64(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))) } } } @@ -110300,12 +110300,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110427,12 +110427,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110507,19 +110507,19 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) /* 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. */ hi = t2 + ar2 lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* 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 @@ -110544,7 +110544,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 = Tuint64_t(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 @@ -110555,13 +110555,13 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl sbits = Tuint64_t(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 @@ -110579,9 +110579,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 @@ -110626,7 +110626,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 @@ -110636,7 +110636,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). */ @@ -110648,17 +110648,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: @@ -110746,10 +110746,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 } @@ -110809,15 +110809,15 @@ 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 = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } } hi = _log_inline(tls, ix, bp) - ehi = y1 * hi - elo = y1**(*Tdouble_t)(unsafe.Pointer(bp)) + float64(X__builtin_fma(tls, y1, hi, -ehi)) + ehi = Tdouble_t(y1 * hi) + elo = float64(y1**(*Tdouble_t)(unsafe.Pointer(bp))) + float64(X__builtin_fma(tls, y1, hi, -ehi)) return _exp_inline(tls, ehi, elo, sign_bias) } @@ -110878,16 +110878,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 } @@ -110917,11 +110917,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 @@ -110989,10 +110989,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 } @@ -111023,22 +111023,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) } } @@ -111163,7 +111163,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 @@ -111263,7 +111263,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++ } @@ -111336,7 +111336,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 @@ -111434,7 +111434,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++ } @@ -111614,7 +111614,7 @@ func Xround(tls *TLS, x3 float64) (r float64) { 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) { @@ -111678,7 +111678,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) { @@ -111732,7 +111732,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)) @@ -111740,7 +111740,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 } @@ -111783,7 +111783,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)) @@ -111791,7 +111791,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 } @@ -111874,10 +111874,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) @@ -111886,7 +111886,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 } @@ -111916,10 +111916,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) @@ -111928,7 +111928,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 } @@ -112110,10 +112110,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 { @@ -112272,10 +112272,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 { @@ -112420,14 +112420,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 } @@ -112468,12 +112468,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 } @@ -112540,7 +112540,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) @@ -112690,7 +112690,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)) } @@ -112823,10 +112823,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 { @@ -112963,18 +112963,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 */ @@ -113035,23 +113035,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 uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113099,12 +113099,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 */ @@ -113200,8 +113200,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: ; @@ -113283,7 +113283,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) @@ -113307,17 +113307,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 } @@ -140285,7 +140285,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))-- } @@ -140348,7 +140348,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 int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -140401,7 +140401,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) @@ -151797,7 +151797,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)), @@ -151806,7 +151806,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), @@ -153140,12 +153140,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 { Finvc float64 @@ -153799,75 +153799,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))), }, } diff --git a/vendor/modernc.org/libc/ccgo_linux_loong64.go b/vendor/modernc.org/libc/ccgo_linux_loong64.go index 419658922..48b0b26f8 100644 --- a/vendor/modernc.org/libc/ccgo_linux_loong64.go +++ b/vendor/modernc.org/libc/ccgo_linux_loong64.go @@ -708,8 +708,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)) } @@ -761,8 +761,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)) } @@ -965,8 +965,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{ @@ -996,7 +996,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{ @@ -1086,7 +1086,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(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 } @@ -1101,17 +1101,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 @@ -1138,7 +1138,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(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 } @@ -1153,17 +1153,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 @@ -1284,24 +1284,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 { @@ -1314,15 +1314,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)) } @@ -1340,7 +1340,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)) } @@ -1353,14 +1353,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)) } @@ -1375,7 +1375,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)) } @@ -1391,14 +1391,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)) } @@ -1414,8 +1414,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)) } @@ -1441,24 +1441,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 { @@ -1471,15 +1471,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)) } @@ -1488,48 +1488,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)) } @@ -1630,8 +1630,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)) } @@ -1710,8 +1710,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)) } @@ -2046,18 +2046,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 { @@ -2069,16 +2069,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)) } @@ -2095,7 +2095,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)) @@ -2130,7 +2130,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)) } @@ -2148,14 +2148,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)) } @@ -2171,8 +2171,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)) } @@ -2204,18 +2204,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 { @@ -2227,16 +2227,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)) } @@ -2244,7 +2244,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)) @@ -2266,27 +2266,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)) } @@ -2414,16 +2414,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)) @@ -2530,16 +2530,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)) @@ -2642,7 +2642,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, @@ -2659,7 +2659,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, @@ -2698,18 +2698,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)) @@ -2740,7 +2740,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, @@ -2757,7 +2757,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, @@ -2785,17 +2785,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)) @@ -13931,7 +13931,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) @@ -25012,7 +25012,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 @@ -25048,7 +25048,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * still be detected. Endianness is taken care of * automatically. */ *(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = 0 - (*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) { @@ -25657,7 +25657,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) { @@ -26207,19 +26207,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 { @@ -26243,14 +26243,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 */ @@ -26404,7 +26404,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: ; @@ -26430,16 +26430,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)) } } } @@ -26581,10 +26581,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) } } @@ -26620,7 +26620,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 @@ -26649,15 +26649,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) { @@ -26682,7 +26682,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) @@ -28234,7 +28234,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(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -30977,7 +30977,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*8))) + return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31591,7 +31591,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n var _ /* z at bp+8 */ 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, p3, plural, q, r, r1, rem, rule, trans, v, v10, v11, v12, v14, v15, v17, v18, v20, v22, v24, v27, 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) { @@ -98272,7 +98272,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { return uint64(0) @@ -99306,7 +99306,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) { @@ -100024,7 +100024,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) { @@ -100190,7 +100190,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 } @@ -100265,7 +100265,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 @@ -100354,7 +100354,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)) + 56 if new1 != 0 { @@ -100397,7 +100397,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 @@ -100438,7 +100438,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 @@ -100482,12 +100482,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 @@ -100507,10 +100507,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 @@ -100535,7 +100535,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 @@ -100560,7 +100560,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) { @@ -100758,7 +100758,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: @@ -100781,7 +100781,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: @@ -100862,14 +100862,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) } } @@ -100880,14 +100880,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 { @@ -100895,14 +100895,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) } } @@ -100914,22 +100914,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 @@ -100938,17 +100938,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 } } @@ -100976,7 +100976,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: ; @@ -101156,7 +101156,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: ; @@ -101180,8 +101180,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: @@ -101190,8 +101190,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 @@ -101284,7 +101284,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: ; @@ -101311,8 +101311,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) @@ -101327,7 +101327,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: @@ -101346,7 +101346,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: ; @@ -101537,19 +101537,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 @@ -101646,14 +101646,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 } @@ -101675,11 +101675,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{ @@ -101722,21 +101722,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 { @@ -101757,7 +101757,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 @@ -101780,7 +101780,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 @@ -101795,12 +101795,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 { @@ -101825,8 +101825,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 } @@ -101847,7 +101847,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) } @@ -101858,24 +101858,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 */ @@ -101888,8 +101888,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 } @@ -101907,7 +101907,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) } @@ -101918,24 +101918,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 @@ -101966,11 +101966,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) @@ -102004,11 +102004,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) @@ -102047,8 +102047,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 } @@ -102068,7 +102068,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) } @@ -102078,21 +102078,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 @@ -102111,8 +102111,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 } @@ -102129,7 +102129,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 */ } @@ -102138,12 +102138,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 } @@ -102187,11 +102187,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 uint64(8) == uint64(4) { @@ -102200,7 +102200,7 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } } @@ -102252,11 +102252,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 uint64(4) == uint64(4) { @@ -102382,7 +102382,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)) @@ -102390,7 +102390,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 @@ -102398,15 +102398,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 { @@ -102492,9 +102492,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 { @@ -102609,9 +102609,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 { @@ -102726,7 +102726,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -102743,7 +102743,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)) @@ -102751,7 +102751,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 @@ -102759,15 +102759,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 { @@ -102824,11 +102824,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 @@ -102874,22 +102874,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint64(4) == uint64(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 @@ -102971,7 +102971,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 @@ -102981,7 +102981,7 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { hx = hx/uint32(3) + _B1 } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -102994,8 +102994,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 @@ -103007,14 +103007,14 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * before the final error is larger than 0.667 ulps. */ *(*float64)(unsafe.Pointer(bp)) = t - *(*Tuint64_t)(unsafe.Pointer(bp)) = (*(*Tuint64_t)(unsafe.Pointer(bp)) + Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000) + *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(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 } @@ -103052,7 +103052,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 { @@ -103066,14 +103066,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) } @@ -103259,9 +103259,9 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } @@ -103334,7 +103334,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } return float64(1) @@ -103366,10 +103366,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 { @@ -103499,19 +103499,19 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 */ @@ -103561,12 +103561,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)) @@ -103661,8 +103661,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 } @@ -103675,18 +103675,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) { @@ -103708,13 +103708,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) @@ -103749,14 +103749,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 { @@ -103769,7 +103769,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 } @@ -103846,8 +103846,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 } @@ -103860,18 +103860,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) { @@ -103893,13 +103893,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) @@ -103934,14 +103934,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 { @@ -103954,7 +103954,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 } @@ -103996,9 +103996,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104006,11 +104006,11 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104027,9 +104027,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 @@ -104080,7 +104080,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 @@ -104090,7 +104090,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)) @@ -104100,17 +104100,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: @@ -104147,8 +104147,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) } @@ -104223,10 +104223,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{ @@ -104286,9 +104286,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = sbits - Uint64FromUint64(1)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104296,11 +104296,11 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104317,9 +104317,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 @@ -104394,17 +104394,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: @@ -104472,11 +104472,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 @@ -104560,7 +104560,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. */ @@ -104577,11 +104577,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 @@ -104675,10 +104675,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 @@ -104701,42 +104701,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 } @@ -104810,10 +104810,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 @@ -104821,7 +104821,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -104836,42 +104836,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 } @@ -104906,7 +104906,7 @@ func Xfabs(tls *TLS, x float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105220,7 +105220,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 { @@ -105230,8 +105230,8 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1)) - ix = ix | Uint64FromUint64(1)<<Int32FromInt32(52) + ix = Tuint64_t(ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1))) + ix = Tuint64_t(ix | Uint64FromUint64(1)<<Int32FromInt32(52)) ix <<= uint64(1) e -= Int32FromInt32(0x3ff) + Int32FromInt32(52) + Int32FromInt32(1) return Tnum{ @@ -105277,11 +105277,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { ny = _normalize(tls, y1) 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*y1 + z + return float64(x1*y1) + 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*y1 + z + return float64(x1*y1) + z } return z } @@ -105422,7 +105422,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } } else { /* exact +-0 */ - return x1*y1 + z + return float64(x1*y1) + z } } e -= d @@ -105443,8 +105443,8 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 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) * r1) - return Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin) + fltmin = float32(float64(Float64FromFloat64(1.0842021401737618e-19)*Float64FromFloat32(1.1754943508222875e-38)) * r1) + 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 */ @@ -105454,11 +105454,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { i = -i } r1 = float64(i) - r1 = Float64FromInt32(2)*r1 - c /* remove top bit */ + r1 = float64(Float64FromInt32(2)*r1) - c /* remove top bit */ /* raise underflow portably, such that it cannot be optimized away */ - tiny = Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1 - r1 += tiny * tiny * (r1 - r1) + tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1) + r1 += float64(Tdouble_t(tiny*tiny) * (r1 - r1)) } } else { /* only round once when scaled */ @@ -105782,11 +105782,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 } @@ -105805,8 +105805,8 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -105823,9 +105823,9 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } /* x mod y */ for { @@ -105835,7 +105835,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 } @@ -105848,7 +105848,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 } @@ -105864,7 +105864,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } /* scale result */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -105925,11 +105925,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 } @@ -105976,7 +105976,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 } @@ -105989,7 +105989,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 } @@ -106048,7 +106048,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 @@ -106061,9 +106061,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106124,11 +106124,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) { @@ -106176,9 +106176,9 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106229,7 +106229,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) { @@ -106308,7 +106308,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) { @@ -106501,8 +106501,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 @@ -106511,10 +106511,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 @@ -106542,7 +106542,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 */ @@ -106552,16 +106552,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 } @@ -106607,12 +106607,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 @@ -106713,9 +106713,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 } @@ -106821,9 +106821,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 } @@ -106845,8 +106845,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 @@ -106855,10 +106855,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 @@ -106885,7 +106885,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 */ @@ -106894,13 +106894,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 } @@ -106941,12 +106941,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 @@ -107046,9 +107046,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 } @@ -107154,9 +107154,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 } @@ -107183,8 +107183,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 @@ -107193,13 +107193,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 @@ -107229,21 +107229,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{ @@ -107289,10 +107289,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 @@ -107392,9 +107392,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 } @@ -107499,9 +107499,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 } @@ -107519,8 +107519,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 @@ -107529,13 +107529,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 @@ -107565,20 +107565,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{ @@ -107620,10 +107620,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 @@ -107723,9 +107723,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 } @@ -107830,9 +107830,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 } @@ -107907,7 +107907,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) @@ -107918,7 +107918,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: @@ -107932,7 +107932,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) @@ -107951,16 +107951,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 } @@ -107970,7 +107970,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: ; @@ -107986,7 +107986,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 { @@ -107994,7 +107994,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: @@ -108008,7 +108008,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) { @@ -108025,9 +108025,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 } } } @@ -108109,7 +108109,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) @@ -108122,7 +108122,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 @@ -108182,7 +108182,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: @@ -108195,7 +108195,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) @@ -108213,16 +108213,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 } @@ -108232,7 +108232,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: ; @@ -108248,7 +108248,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 { @@ -108256,7 +108256,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: @@ -108270,7 +108270,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) { @@ -108287,9 +108287,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 } } } @@ -108352,7 +108352,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 @@ -108469,8 +108469,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 @@ -108517,7 +108517,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 { @@ -108537,7 +108537,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) { @@ -108575,31 +108575,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): @@ -108623,11 +108623,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))) } } } @@ -108726,10 +108726,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: */ @@ -108774,7 +108774,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 { @@ -108794,7 +108794,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) { @@ -108832,31 +108832,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): @@ -108880,11 +108880,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))) } } } @@ -109036,17 +109036,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 @@ -109068,9 +109068,9 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109078,7 +109078,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109091,19 +109091,19 @@ 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. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) 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 @@ -109150,7 +109150,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) @@ -109176,12 +109176,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) */ @@ -109189,12 +109189,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 @@ -109244,7 +109244,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) @@ -109271,19 +109271,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) { @@ -109385,15 +109385,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 */ @@ -109442,7 +109442,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109486,14 +109486,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) { @@ -109543,15 +109543,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - hi = r * X__log2_data.Finvln2hi - lo = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi) - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(r * X__log2_data.Finvln2hi) + lo = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) + 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 v6 = y @@ -109572,9 +109572,9 @@ func Xlog2(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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109582,7 +109582,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG2_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109596,21 +109596,21 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* log2(x) = log2(z/c) + log2(c) + k. */ /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) - t1 = r * X__log2_data.Finvln2hi - t2 = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) + t1 = Tdouble_t(r * X__log2_data.Finvln2hi) + t2 = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) /* 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 v10 = y goto _11 @@ -109669,7 +109669,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)) } @@ -109691,14 +109691,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 @@ -109760,10 +109760,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)) } @@ -109786,10 +109786,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)) } @@ -109812,10 +109812,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)) } @@ -109859,7 +109859,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)) } @@ -109880,13 +109880,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 @@ -110015,21 +110015,21 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { return x } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } /* no integral part*/ if e < 0 { p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x } - mask = -Uint64FromUint64(1) >> Int32FromInt32(12) >> e + mask = uint64(-Uint64FromUint64(1) >> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = *(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110184,13 +110184,13 @@ _2: if *(*Tuint64_t)(unsafe.Pointer(bp + 8)) == *(*Tuint64_t)(unsafe.Pointer(bp + 16)) { return y3 } - ax = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) - ay = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + ax = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + ay = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) if ax == uint64(0) { if ay == uint64(0) { return y3 } - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1) + *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1)) } else { if ax > ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<<Int32FromInt32(63)) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8))-- @@ -110214,12 +110214,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(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 uint64(8) == uint64(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))) } } } @@ -110314,12 +110314,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110441,12 +110441,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110495,7 +110495,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { tmp = ix - uint64(OFF2) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(POW_LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(POW_LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ @@ -110519,21 +110519,21 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) /* 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. */ hi = t2 + ar2 - lo3 = X__builtin_fma(tls, ar, r, -ar2) + lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* 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 @@ -110556,9 +110556,9 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110566,16 +110566,16 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110593,9 +110593,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 @@ -110640,7 +110640,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 @@ -110650,7 +110650,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). */ @@ -110662,17 +110662,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: @@ -110760,10 +110760,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 } @@ -110823,15 +110823,15 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } } hi = _log_inline(tls, ix, bp) - ehi = y1 * hi - elo = y1**(*Tdouble_t)(unsafe.Pointer(bp)) + X__builtin_fma(tls, y1, hi, -ehi) + ehi = Tdouble_t(y1 * hi) + elo = float64(y1**(*Tdouble_t)(unsafe.Pointer(bp))) + float64(X__builtin_fma(tls, y1, hi, -ehi)) return _exp_inline(tls, ehi, elo, sign_bias) } @@ -110892,16 +110892,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 } @@ -110931,11 +110931,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 @@ -111003,10 +111003,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 } @@ -111037,22 +111037,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) } } @@ -111177,7 +111177,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 @@ -111197,8 +111197,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -111215,9 +111215,9 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } q = uint32(0) if ex < ey { @@ -111267,7 +111267,7 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -111277,7 +111277,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++ } @@ -111350,7 +111350,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 @@ -111448,7 +111448,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++ } @@ -111625,10 +111625,10 @@ func Xround(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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) { @@ -111692,7 +111692,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) { @@ -111746,7 +111746,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)) @@ -111754,7 +111754,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 } @@ -111797,7 +111797,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)) @@ -111805,7 +111805,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 } @@ -111888,10 +111888,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) @@ -111900,7 +111900,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 } @@ -111930,10 +111930,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) @@ -111942,7 +111942,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 } @@ -112124,10 +112124,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 { @@ -112286,10 +112286,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 { @@ -112434,14 +112434,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 } @@ -112482,12 +112482,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 } @@ -112554,7 +112554,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) @@ -112704,7 +112704,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)) } @@ -112837,10 +112837,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 { @@ -112977,18 +112977,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 */ @@ -113049,23 +113049,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 uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113113,12 +113113,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 */ @@ -113214,8 +113214,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: ; @@ -113297,7 +113297,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) @@ -113321,17 +113321,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 } @@ -113382,7 +113382,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if e < int32(12) { e = int32(1) } - m = -Uint64FromUint64(1) >> e + m = uint64(-Uint64FromUint64(1) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&m == uint64(0) { return x3 } @@ -113392,7 +113392,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 @@ -116497,7 +116497,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) @@ -116698,7 +116698,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize *(*Twchar_t)(unsafe.Pointer(wc)) = v1 return BoolUint64(!!(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) @@ -116869,7 +116869,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) @@ -117097,7 +117097,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) @@ -117167,7 +117167,7 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { *(*int8)(unsafe.Pointer(s)) = int8(wc) return uint64(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) @@ -117374,7 +117374,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) @@ -121000,10 +121000,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) + 144 + return uintptr(___get_tp(tls)) + 144 } func Xherror(tls *TLS, msg uintptr) { @@ -127803,7 +127803,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } if v9 = Uint32FromInt8(*(*int8)(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) @@ -134256,7 +134256,7 @@ func Xraise(tls *TLS, sig int32) (r int32) { var _ /* set at bp+0 */ Tsigset_t _ = ret X__block_app_sigs(tls, bp) - ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid), int64(sig))))) + ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid), int64(sig))))) X__restore_sigs(tls, bp) return ret } @@ -135071,13 +135071,13 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r return ret } *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff), + Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff)), Fst_ino: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_ino, Fst_mode: uint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_mode), Fst_nlink: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_nlink, Fst_uid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_uid, Fst_gid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_gid, - Fst_rdev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff), + Fst_rdev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff)), Fst_size: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_size), Fst_blksize: Int32FromUint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_blksize), Fst_blocks: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_blocks), @@ -136309,7 +136309,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -136553,7 +136553,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -136704,7 +136704,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 { @@ -137225,7 +137225,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -137277,7 +137277,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var v2 uint8 var _ /* mbc at bp+0 */ [4]int8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137369,7 +137369,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { var _ /* buf at bp+8 */ [1024]uint8 _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -137745,7 +137745,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 @@ -137773,7 +137773,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 } } } @@ -137801,7 +137801,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { var v11, v5 bool var v2 uintptr _, _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v11, v2, v3, v5, v7, v9 - self = ___get_tp(tls) + self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) if owner & ^Int32FromInt32(MAYBE_WAITERS) == tid { @@ -137891,7 +137891,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) @@ -138149,7 +138149,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -138325,7 +138325,7 @@ func Xgetchar(tls *TLS) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = uintptr(unsafe.Pointer(&X__stdin_FILE)) l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -139093,7 +139093,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -139279,7 +139279,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v1 = c1 v2 = uintptr(unsafe.Pointer(&X__stdout_FILE)) l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -139806,7 +139806,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -140058,7 +140058,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -140080,7 +140080,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -140269,7 +140269,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))-- } @@ -140332,7 +140332,7 @@ _4: v14 = s s++ *(*int8)(unsafe.Pointer(v14)) = int8(int32(_xdigits1[x]) | t&int32(32)) - y = Float64FromInt32(16) * (y - float64(x)) + y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -140385,7 +140385,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) @@ -142235,7 +142235,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -142257,7 +142257,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -144428,7 +144428,7 @@ func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _strtox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _strtox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -144436,7 +144436,7 @@ func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_strtox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_strtox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -144708,7 +144708,7 @@ func Xwcstoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _wcstox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _wcstox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -144716,7 +144716,7 @@ func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_wcstox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_wcstox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xwcstoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -148808,7 +148808,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { n /= uint64(2) } else { a = m @@ -148848,7 +148848,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { } /* If t is before first transition, use the above-found type * and the index-zero (after transition) type as the alt. */ - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) } @@ -149968,7 +149968,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) { @@ -150712,7 +150712,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) { @@ -151790,7 +151790,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)), @@ -151799,7 +151799,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), @@ -153133,12 +153133,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 { Finvc float64 @@ -153792,75 +153792,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))), }, } diff --git a/vendor/modernc.org/libc/ccgo_linux_ppc64le.go b/vendor/modernc.org/libc/ccgo_linux_ppc64le.go index 48004bfcb..9244f4445 100644 --- a/vendor/modernc.org/libc/ccgo_linux_ppc64le.go +++ b/vendor/modernc.org/libc/ccgo_linux_ppc64le.go @@ -647,8 +647,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)) } @@ -700,8 +700,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)) } @@ -904,8 +904,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{ @@ -935,7 +935,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{ @@ -1025,7 +1025,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(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 } @@ -1040,17 +1040,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 @@ -1077,7 +1077,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(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 } @@ -1092,17 +1092,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 @@ -1223,24 +1223,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 { @@ -1253,15 +1253,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)) } @@ -1279,7 +1279,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)) } @@ -1292,14 +1292,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)) } @@ -1314,7 +1314,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)) } @@ -1330,14 +1330,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)) } @@ -1353,8 +1353,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)) } @@ -1380,24 +1380,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 { @@ -1410,15 +1410,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)) } @@ -1427,48 +1427,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)) } @@ -1569,8 +1569,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)) } @@ -1649,8 +1649,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)) } @@ -1985,18 +1985,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 { @@ -2008,16 +2008,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)) } @@ -2034,7 +2034,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)) @@ -2069,7 +2069,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)) } @@ -2087,14 +2087,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)) } @@ -2110,8 +2110,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)) } @@ -2143,18 +2143,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 { @@ -2166,16 +2166,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)) } @@ -2183,7 +2183,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)) @@ -2205,27 +2205,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)) } @@ -2353,16 +2353,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)) @@ -2469,16 +2469,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)) @@ -2581,7 +2581,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, @@ -2598,7 +2598,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, @@ -2637,18 +2637,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)) @@ -2679,7 +2679,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, @@ -2696,7 +2696,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, @@ -2724,17 +2724,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)) @@ -14081,7 +14081,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) @@ -25160,7 +25160,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 @@ -25196,7 +25196,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * still be detected. Endianness is taken care of * automatically. */ *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) - (*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) { @@ -25806,7 +25806,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) { @@ -26481,19 +26481,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 { @@ -26517,14 +26517,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 */ @@ -26678,7 +26678,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: ; @@ -26704,16 +26704,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)) } } } @@ -26855,10 +26855,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) } } @@ -26894,7 +26894,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 @@ -26923,15 +26923,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) { @@ -26956,7 +26956,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) @@ -28528,7 +28528,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(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -31368,7 +31368,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*8))) + return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31976,7 +31976,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n var _ /* z at bp+8 */ 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, p3, plural, q, r, r1, rem, rule, trans, v, v10, v11, v12, v14, v15, v17, v18, v19, v21, v23, v24, v26, v29, 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) { @@ -98653,7 +98653,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { return uint64(0) @@ -99687,7 +99687,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) { @@ -100405,7 +100405,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) { @@ -100571,7 +100571,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 } @@ -100646,7 +100646,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 @@ -100735,7 +100735,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)) + 56 if new1 != 0 { @@ -100778,7 +100778,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 @@ -100819,7 +100819,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 @@ -100863,12 +100863,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 @@ -100888,10 +100888,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 @@ -100916,7 +100916,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 @@ -100941,7 +100941,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) { @@ -101139,7 +101139,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: @@ -101162,7 +101162,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: @@ -101243,14 +101243,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) } } @@ -101261,14 +101261,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 { @@ -101276,14 +101276,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) } } @@ -101295,22 +101295,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 @@ -101319,17 +101319,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 } } @@ -101357,7 +101357,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: ; @@ -101537,7 +101537,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: ; @@ -101561,8 +101561,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: @@ -101571,8 +101571,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 @@ -101665,7 +101665,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: ; @@ -101692,8 +101692,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) @@ -101708,7 +101708,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: @@ -101727,7 +101727,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: ; @@ -101918,19 +101918,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 @@ -102027,14 +102027,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 } @@ -102056,11 +102056,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{ @@ -102103,21 +102103,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 { @@ -102138,7 +102138,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 @@ -102161,7 +102161,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 @@ -102176,12 +102176,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 { @@ -102206,8 +102206,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 } @@ -102228,7 +102228,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) } @@ -102239,24 +102239,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 */ @@ -102269,8 +102269,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 } @@ -102288,7 +102288,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) } @@ -102299,24 +102299,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 @@ -102347,11 +102347,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) @@ -102385,11 +102385,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) @@ -102428,8 +102428,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 } @@ -102449,7 +102449,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) } @@ -102459,21 +102459,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 @@ -102492,8 +102492,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 } @@ -102510,7 +102510,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 */ } @@ -102519,12 +102519,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 } @@ -102568,11 +102568,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 uint64(8) == uint64(4) { @@ -102581,7 +102581,7 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } } @@ -102633,11 +102633,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 uint64(4) == uint64(4) { @@ -102763,7 +102763,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)) @@ -102771,7 +102771,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 @@ -102779,15 +102779,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 { @@ -102873,9 +102873,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 { @@ -102990,9 +102990,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 { @@ -103107,7 +103107,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -103124,7 +103124,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)) @@ -103132,7 +103132,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 @@ -103140,15 +103140,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 { @@ -103205,11 +103205,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 @@ -103255,22 +103255,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint64(4) == uint64(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 @@ -103352,7 +103352,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 @@ -103362,7 +103362,7 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { hx = hx/uint32(3) + _B1 } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103375,8 +103375,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 @@ -103388,14 +103388,14 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * before the final error is larger than 0.667 ulps. */ *(*float64)(unsafe.Pointer(bp)) = t - *(*Tuint64_t)(unsafe.Pointer(bp)) = (*(*Tuint64_t)(unsafe.Pointer(bp)) + Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000) + *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(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 } @@ -103433,7 +103433,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 { @@ -103447,14 +103447,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) } @@ -103640,9 +103640,9 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } @@ -103715,7 +103715,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } return float64(1) @@ -103747,10 +103747,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 { @@ -103880,19 +103880,19 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 */ @@ -103942,12 +103942,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)) @@ -104042,8 +104042,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 } @@ -104056,18 +104056,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) { @@ -104089,13 +104089,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) @@ -104130,14 +104130,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 { @@ -104150,7 +104150,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 } @@ -104227,8 +104227,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 } @@ -104241,18 +104241,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) { @@ -104274,13 +104274,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) @@ -104315,14 +104315,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 { @@ -104335,7 +104335,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 } @@ -104377,9 +104377,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104387,11 +104387,11 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104408,9 +104408,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 @@ -104461,7 +104461,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 @@ -104471,7 +104471,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)) @@ -104481,17 +104481,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: @@ -104528,8 +104528,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) } @@ -104604,10 +104604,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{ @@ -104667,9 +104667,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = sbits - Uint64FromUint64(1)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104677,11 +104677,11 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104698,9 +104698,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 @@ -104775,17 +104775,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: @@ -104853,11 +104853,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 @@ -104941,7 +104941,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. */ @@ -104958,11 +104958,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 @@ -105056,10 +105056,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 @@ -105082,42 +105082,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 } @@ -105191,10 +105191,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 @@ -105202,7 +105202,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -105217,42 +105217,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 } @@ -105287,7 +105287,7 @@ func Xfabs(tls *TLS, x float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105601,7 +105601,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 { @@ -105611,8 +105611,8 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1)) - ix = ix | Uint64FromUint64(1)<<Int32FromInt32(52) + ix = Tuint64_t(ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1))) + ix = Tuint64_t(ix | Uint64FromUint64(1)<<Int32FromInt32(52)) ix <<= uint64(1) e -= Int32FromInt32(0x3ff) + Int32FromInt32(52) + Int32FromInt32(1) return Tnum{ @@ -105657,11 +105657,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 } @@ -105752,7 +105752,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 @@ -105773,8 +105773,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 */ @@ -105784,11 +105784,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 */ @@ -106112,11 +106112,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 } @@ -106135,8 +106135,8 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -106153,9 +106153,9 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } /* x mod y */ for { @@ -106165,7 +106165,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 } @@ -106178,7 +106178,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 } @@ -106194,7 +106194,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } /* scale result */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -106255,11 +106255,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 } @@ -106306,7 +106306,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 } @@ -106319,7 +106319,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 } @@ -106378,7 +106378,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 @@ -106391,9 +106391,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106454,11 +106454,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) { @@ -106506,9 +106506,9 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106559,7 +106559,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) { @@ -106638,7 +106638,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) { @@ -106831,8 +106831,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 @@ -106841,10 +106841,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 @@ -106872,7 +106872,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 */ @@ -106882,16 +106882,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 } @@ -106937,12 +106937,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 @@ -107043,9 +107043,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 } @@ -107151,9 +107151,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 } @@ -107175,8 +107175,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 @@ -107185,10 +107185,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 @@ -107215,7 +107215,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 */ @@ -107224,13 +107224,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 } @@ -107271,12 +107271,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 @@ -107376,9 +107376,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 } @@ -107484,9 +107484,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 } @@ -107513,8 +107513,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 @@ -107523,13 +107523,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 @@ -107559,21 +107559,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{ @@ -107619,10 +107619,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 @@ -107722,9 +107722,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 } @@ -107829,9 +107829,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 } @@ -107849,8 +107849,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 @@ -107859,13 +107859,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 @@ -107895,20 +107895,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{ @@ -107950,10 +107950,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 @@ -108053,9 +108053,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 } @@ -108160,9 +108160,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 } @@ -108237,7 +108237,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) @@ -108248,7 +108248,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: @@ -108262,7 +108262,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) @@ -108281,16 +108281,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 } @@ -108300,7 +108300,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: ; @@ -108316,7 +108316,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 { @@ -108324,7 +108324,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: @@ -108338,7 +108338,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) { @@ -108355,9 +108355,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 } } } @@ -108439,7 +108439,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) @@ -108452,7 +108452,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 @@ -108512,7 +108512,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: @@ -108525,7 +108525,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) @@ -108543,16 +108543,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 } @@ -108562,7 +108562,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: ; @@ -108578,7 +108578,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 { @@ -108586,7 +108586,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: @@ -108600,7 +108600,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) { @@ -108617,9 +108617,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 } } } @@ -108682,7 +108682,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 @@ -108799,8 +108799,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 @@ -108847,7 +108847,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 { @@ -108867,7 +108867,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) { @@ -108905,31 +108905,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): @@ -108953,11 +108953,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))) } } } @@ -109056,10 +109056,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: */ @@ -109104,7 +109104,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 { @@ -109124,7 +109124,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) { @@ -109162,31 +109162,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): @@ -109210,11 +109210,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))) } } } @@ -109349,17 +109349,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 @@ -109381,9 +109381,9 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109391,7 +109391,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109404,19 +109404,19 @@ 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. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) 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 @@ -109463,7 +109463,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) @@ -109489,12 +109489,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) */ @@ -109502,12 +109502,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 @@ -109557,7 +109557,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) @@ -109584,19 +109584,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) { @@ -109698,15 +109698,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 */ @@ -109755,7 +109755,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109799,14 +109799,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) { @@ -109856,15 +109856,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - hi = r * X__log2_data.Finvln2hi - lo = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi) - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(r * X__log2_data.Finvln2hi) + lo = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) + 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 v6 = y @@ -109885,9 +109885,9 @@ func Xlog2(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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109895,7 +109895,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG2_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109909,21 +109909,21 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* log2(x) = log2(z/c) + log2(c) + k. */ /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) - t1 = r * X__log2_data.Finvln2hi - t2 = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) + t1 = Tdouble_t(r * X__log2_data.Finvln2hi) + t2 = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) /* 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 v10 = y goto _11 @@ -109982,7 +109982,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)) } @@ -110004,14 +110004,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 @@ -110073,10 +110073,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)) } @@ -110099,10 +110099,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)) } @@ -110125,10 +110125,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)) } @@ -110172,7 +110172,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)) } @@ -110193,13 +110193,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 @@ -110328,21 +110328,21 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { return x } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } /* no integral part*/ if e < 0 { p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x } - mask = -Uint64FromUint64(1) >> Int32FromInt32(12) >> e + mask = uint64(-Uint64FromUint64(1) >> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = *(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110497,13 +110497,13 @@ _2: if *(*Tuint64_t)(unsafe.Pointer(bp + 8)) == *(*Tuint64_t)(unsafe.Pointer(bp + 16)) { return y3 } - ax = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) - ay = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + ax = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + ay = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) if ax == uint64(0) { if ay == uint64(0) { return y3 } - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1) + *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1)) } else { if ax > ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<<Int32FromInt32(63)) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8))-- @@ -110527,12 +110527,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(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 uint64(8) == uint64(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))) } } } @@ -110627,12 +110627,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110754,12 +110754,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110808,7 +110808,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { tmp = ix - uint64(OFF2) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(POW_LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(POW_LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ @@ -110832,21 +110832,21 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) /* 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. */ hi = t2 + ar2 - lo3 = X__builtin_fma(tls, ar, r, -ar2) + lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* 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 @@ -110869,9 +110869,9 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110879,16 +110879,16 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110906,9 +110906,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 @@ -110953,7 +110953,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 @@ -110963,7 +110963,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). */ @@ -110975,17 +110975,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: @@ -111073,10 +111073,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 } @@ -111136,15 +111136,15 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } } hi = _log_inline(tls, ix, bp) - ehi = y1 * hi - elo = y1**(*Tdouble_t)(unsafe.Pointer(bp)) + X__builtin_fma(tls, y1, hi, -ehi) + ehi = Tdouble_t(y1 * hi) + elo = float64(y1**(*Tdouble_t)(unsafe.Pointer(bp))) + float64(X__builtin_fma(tls, y1, hi, -ehi)) return _exp_inline(tls, ehi, elo, sign_bias) } @@ -111205,16 +111205,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 } @@ -111244,11 +111244,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 @@ -111316,10 +111316,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 } @@ -111350,22 +111350,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) } } @@ -111490,7 +111490,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 @@ -111510,8 +111510,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -111528,9 +111528,9 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } q = uint32(0) if ex < ey { @@ -111580,7 +111580,7 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -111590,7 +111590,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++ } @@ -111663,7 +111663,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 @@ -111761,7 +111761,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++ } @@ -111938,10 +111938,10 @@ func Xround(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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) { @@ -112005,7 +112005,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) { @@ -112059,7 +112059,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)) @@ -112067,7 +112067,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 } @@ -112110,7 +112110,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)) @@ -112118,7 +112118,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 } @@ -112201,10 +112201,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) @@ -112213,7 +112213,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 } @@ -112243,10 +112243,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) @@ -112255,7 +112255,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 } @@ -112437,10 +112437,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 { @@ -112599,10 +112599,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 { @@ -112747,14 +112747,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 } @@ -112795,12 +112795,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 } @@ -112867,7 +112867,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) @@ -113017,7 +113017,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)) } @@ -113150,10 +113150,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 { @@ -113290,18 +113290,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 */ @@ -113362,23 +113362,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 uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113426,12 +113426,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 */ @@ -113527,8 +113527,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: ; @@ -113610,7 +113610,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) @@ -113634,17 +113634,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 } @@ -113695,7 +113695,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if e < int32(12) { e = int32(1) } - m = -Uint64FromUint64(1) >> e + m = uint64(-Uint64FromUint64(1) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&m == uint64(0) { return x3 } @@ -113705,7 +113705,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 @@ -116898,7 +116898,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) @@ -117099,7 +117099,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize *(*Twchar_t)(unsafe.Pointer(wc)) = v1 return BoolUint64(!!(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) @@ -117270,7 +117270,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) @@ -117498,7 +117498,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) @@ -117568,7 +117568,7 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(wc) return uint64(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) @@ -117775,7 +117775,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) @@ -121611,10 +121611,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) + 144 + return uintptr(___get_tp(tls)) + 144 } func Xherror(tls *TLS, msg uintptr) { @@ -128720,7 +128720,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) @@ -135169,7 +135169,7 @@ func Xraise(tls *TLS, sig int32) (r int32) { var _ /* set at bp+0 */ Tsigset_t _ = ret X__block_app_sigs(tls, bp) - ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid), int64(sig))))) + ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid), int64(sig))))) X__restore_sigs(tls, bp) return ret } @@ -135992,13 +135992,13 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r return ret } *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff), + Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff)), Fst_ino: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_ino, Fst_nlink: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_nlink), Fst_mode: uint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_mode), Fst_uid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_uid, Fst_gid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_gid, - Fst_rdev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff), + Fst_rdev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff)), Fst_size: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_size), Fst_blksize: Int64FromUint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_blksize), Fst_blocks: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_blocks), @@ -137341,7 +137341,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -137585,7 +137585,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137736,7 +137736,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 { @@ -138251,7 +138251,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -138303,7 +138303,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -138395,7 +138395,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { var _ /* buf at bp+8 */ [1024]uint8 _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138771,7 +138771,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 @@ -138799,7 +138799,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 } } } @@ -138827,7 +138827,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { var v13, v6 bool var v2, v3, v8 uintptr _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v11, v13, v2, v3, v4, v6, v8, v9 - self = ___get_tp(tls) + self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) if owner & ^Int32FromInt32(MAYBE_WAITERS) == tid { @@ -138914,7 +138914,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) @@ -139166,7 +139166,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -139336,7 +139336,7 @@ func Xgetchar(tls *TLS) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = uintptr(unsafe.Pointer(&X__stdin_FILE)) l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -140098,7 +140098,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -140278,7 +140278,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v1 = c1 v2 = uintptr(unsafe.Pointer(&X__stdout_FILE)) l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -140805,7 +140805,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -141057,7 +141057,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -141079,7 +141079,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -141268,7 +141268,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))-- } @@ -141331,7 +141331,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 int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -141384,7 +141384,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) @@ -143234,7 +143234,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -143256,7 +143256,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -145427,7 +145427,7 @@ func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _strtox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _strtox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -145435,7 +145435,7 @@ func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_strtox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_strtox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -145707,7 +145707,7 @@ func Xwcstoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _wcstox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _wcstox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -145715,7 +145715,7 @@ func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_wcstox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_wcstox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xwcstoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -149807,7 +149807,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { n /= uint64(2) } else { a = m @@ -149847,7 +149847,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { } /* If t is before first transition, use the above-found type * and the index-zero (after transition) type as the alt. */ - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) } @@ -150968,7 +150968,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) { @@ -151712,7 +151712,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) { @@ -152814,7 +152814,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)), @@ -152823,7 +152823,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), @@ -154157,12 +154157,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 { Finvc float64 @@ -154816,75 +154816,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))), }, } diff --git a/vendor/modernc.org/libc/ccgo_linux_riscv64.go b/vendor/modernc.org/libc/ccgo_linux_riscv64.go index 1a07d724a..7a0edb178 100644 --- a/vendor/modernc.org/libc/ccgo_linux_riscv64.go +++ b/vendor/modernc.org/libc/ccgo_linux_riscv64.go @@ -602,8 +602,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)) } @@ -655,8 +655,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)) } @@ -859,8 +859,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{ @@ -890,7 +890,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{ @@ -980,7 +980,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(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 } @@ -995,17 +995,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 @@ -1032,7 +1032,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(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 } @@ -1047,17 +1047,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 @@ -1178,24 +1178,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 { @@ -1208,15 +1208,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)) } @@ -1234,7 +1234,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)) } @@ -1247,14 +1247,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)) } @@ -1269,7 +1269,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)) } @@ -1285,14 +1285,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)) } @@ -1308,8 +1308,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)) } @@ -1335,24 +1335,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 { @@ -1365,15 +1365,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)) } @@ -1382,48 +1382,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)) } @@ -1524,8 +1524,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)) } @@ -1604,8 +1604,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)) } @@ -1940,18 +1940,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 { @@ -1963,16 +1963,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)) } @@ -1989,7 +1989,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)) @@ -2024,7 +2024,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)) } @@ -2042,14 +2042,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)) } @@ -2065,8 +2065,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)) } @@ -2098,18 +2098,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 { @@ -2121,16 +2121,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)) } @@ -2138,7 +2138,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)) @@ -2160,27 +2160,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)) } @@ -2308,16 +2308,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)) @@ -2424,16 +2424,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)) @@ -2536,7 +2536,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, @@ -2553,7 +2553,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, @@ -2592,18 +2592,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)) @@ -2634,7 +2634,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, @@ -2651,7 +2651,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, @@ -2679,17 +2679,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)) @@ -13837,7 +13837,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) @@ -24918,7 +24918,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 @@ -24954,7 +24954,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * still be detected. Endianness is taken care of * automatically. */ *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) - (*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) { @@ -25563,7 +25563,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) { @@ -26113,19 +26113,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 { @@ -26149,14 +26149,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 */ @@ -26310,7 +26310,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: ; @@ -26336,16 +26336,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)) } } } @@ -26487,10 +26487,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) } } @@ -26526,7 +26526,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 @@ -26555,15 +26555,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) { @@ -26588,7 +26588,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) @@ -28328,7 +28328,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(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -31140,7 +31140,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*8))) + return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31722,7 +31722,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n var _ /* z at bp+8 */ 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, p1, plural, q, r, rem, rule, tmp, trans, v10, v11, v12, v14, v15, v17, v20, 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) { @@ -98375,7 +98375,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { return uint64(0) @@ -99409,7 +99409,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) { @@ -100127,7 +100127,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) { @@ -100293,7 +100293,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 } @@ -100368,7 +100368,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 @@ -100457,7 +100457,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)) + 56 if new1 != 0 { @@ -100500,7 +100500,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 @@ -100541,7 +100541,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 @@ -100585,12 +100585,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 @@ -100610,10 +100610,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 @@ -100638,7 +100638,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 @@ -100663,7 +100663,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) { @@ -100861,7 +100861,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: @@ -100884,7 +100884,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: @@ -100965,14 +100965,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) } } @@ -100983,14 +100983,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 { @@ -100998,14 +100998,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) } } @@ -101017,22 +101017,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 @@ -101041,17 +101041,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 } } @@ -101079,7 +101079,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: ; @@ -101259,7 +101259,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: ; @@ -101283,8 +101283,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: @@ -101293,8 +101293,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 @@ -101387,7 +101387,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: ; @@ -101414,8 +101414,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) @@ -101430,7 +101430,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: @@ -101449,7 +101449,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: ; @@ -101640,19 +101640,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 @@ -101749,14 +101749,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 } @@ -101778,11 +101778,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{ @@ -101825,21 +101825,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 { @@ -101860,7 +101860,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 @@ -101883,7 +101883,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 @@ -101898,12 +101898,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 { @@ -101928,8 +101928,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 } @@ -101950,7 +101950,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) } @@ -101961,24 +101961,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 */ @@ -101991,8 +101991,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 } @@ -102010,7 +102010,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) } @@ -102021,24 +102021,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 @@ -102069,11 +102069,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) @@ -102107,11 +102107,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) @@ -102150,8 +102150,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 } @@ -102171,7 +102171,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) } @@ -102181,21 +102181,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 @@ -102214,8 +102214,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 } @@ -102232,7 +102232,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 */ } @@ -102241,12 +102241,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 } @@ -102290,11 +102290,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 uint64(8) == uint64(4) { @@ -102303,7 +102303,7 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } } @@ -102355,11 +102355,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 uint64(4) == uint64(4) { @@ -102485,7 +102485,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)) @@ -102493,7 +102493,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 @@ -102501,15 +102501,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 { @@ -102595,9 +102595,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 { @@ -102712,9 +102712,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 { @@ -102829,7 +102829,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -102846,7 +102846,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)) @@ -102854,7 +102854,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 @@ -102862,15 +102862,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 { @@ -102927,11 +102927,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 @@ -102977,22 +102977,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint64(4) == uint64(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 @@ -103074,7 +103074,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 @@ -103084,7 +103084,7 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { hx = hx/uint32(3) + _B1 } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103097,8 +103097,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 @@ -103110,14 +103110,14 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * before the final error is larger than 0.667 ulps. */ *(*float64)(unsafe.Pointer(bp)) = t - *(*Tuint64_t)(unsafe.Pointer(bp)) = (*(*Tuint64_t)(unsafe.Pointer(bp)) + Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000) + *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(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 } @@ -103155,7 +103155,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 { @@ -103169,14 +103169,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) } @@ -103362,9 +103362,9 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } @@ -103437,7 +103437,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } return float64(1) @@ -103469,10 +103469,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 { @@ -103602,19 +103602,19 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 */ @@ -103664,12 +103664,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)) @@ -103764,8 +103764,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 } @@ -103778,18 +103778,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) { @@ -103811,13 +103811,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) @@ -103852,14 +103852,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 { @@ -103872,7 +103872,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 } @@ -103949,8 +103949,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 } @@ -103963,18 +103963,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) { @@ -103996,13 +103996,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) @@ -104037,14 +104037,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 { @@ -104057,7 +104057,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 } @@ -104099,9 +104099,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104109,11 +104109,11 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104130,9 +104130,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 @@ -104183,7 +104183,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 @@ -104193,7 +104193,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)) @@ -104203,17 +104203,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: @@ -104250,8 +104250,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) } @@ -104326,10 +104326,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{ @@ -104389,9 +104389,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = sbits - Uint64FromUint64(1)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104399,11 +104399,11 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104420,9 +104420,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 @@ -104497,17 +104497,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: @@ -104575,11 +104575,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 @@ -104663,7 +104663,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. */ @@ -104680,11 +104680,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 @@ -104778,10 +104778,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 @@ -104804,42 +104804,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 } @@ -104913,10 +104913,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 @@ -104924,7 +104924,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -104939,42 +104939,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 } @@ -105009,7 +105009,7 @@ func Xfabs(tls *TLS, x float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105323,7 +105323,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 { @@ -105333,8 +105333,8 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1)) - ix = ix | Uint64FromUint64(1)<<Int32FromInt32(52) + ix = Tuint64_t(ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1))) + ix = Tuint64_t(ix | Uint64FromUint64(1)<<Int32FromInt32(52)) ix <<= uint64(1) e -= Int32FromInt32(0x3ff) + Int32FromInt32(52) + Int32FromInt32(1) return Tnum{ @@ -105380,11 +105380,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { ny = _normalize(tls, y1) 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*y1 + z + return float64(x1*y1) + 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*y1 + z + return float64(x1*y1) + z } return z } @@ -105525,7 +105525,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } } else { /* exact +-0 */ - return x1*y1 + z + return float64(x1*y1) + z } } e -= d @@ -105546,8 +105546,8 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 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) * r1) - return Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin) + fltmin = float32(float64(Float64FromFloat64(1.0842021401737618e-19)*Float64FromFloat32(1.1754943508222875e-38)) * r1) + 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 */ @@ -105557,11 +105557,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { i = -i } r1 = float64(i) - r1 = Float64FromInt32(2)*r1 - c /* remove top bit */ + r1 = float64(Float64FromInt32(2)*r1) - c /* remove top bit */ /* raise underflow portably, such that it cannot be optimized away */ - tiny = Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1 - r1 += tiny * tiny * (r1 - r1) + tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1) + r1 += float64(Tdouble_t(tiny*tiny) * (r1 - r1)) } } else { /* only round once when scaled */ @@ -105885,11 +105885,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 } @@ -105908,8 +105908,8 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -105926,9 +105926,9 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } /* x mod y */ for { @@ -105938,7 +105938,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 } @@ -105951,7 +105951,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 } @@ -105967,7 +105967,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } /* scale result */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -106028,11 +106028,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 } @@ -106079,7 +106079,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 } @@ -106092,7 +106092,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 } @@ -106151,7 +106151,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 @@ -106164,9 +106164,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106227,11 +106227,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) { @@ -106279,9 +106279,9 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106332,7 +106332,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) { @@ -106411,7 +106411,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) { @@ -106604,8 +106604,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 @@ -106614,10 +106614,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 @@ -106645,7 +106645,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 */ @@ -106655,16 +106655,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 } @@ -106710,12 +106710,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 @@ -106816,9 +106816,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 } @@ -106924,9 +106924,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 } @@ -106948,8 +106948,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 @@ -106958,10 +106958,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 @@ -106988,7 +106988,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 */ @@ -106997,13 +106997,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 } @@ -107044,12 +107044,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 @@ -107149,9 +107149,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 } @@ -107257,9 +107257,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 } @@ -107286,8 +107286,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 @@ -107296,13 +107296,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 @@ -107332,21 +107332,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{ @@ -107392,10 +107392,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 @@ -107495,9 +107495,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 } @@ -107602,9 +107602,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 } @@ -107622,8 +107622,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 @@ -107632,13 +107632,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 @@ -107668,20 +107668,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{ @@ -107723,10 +107723,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 @@ -107826,9 +107826,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 } @@ -107933,9 +107933,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 } @@ -108010,7 +108010,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) @@ -108021,7 +108021,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: @@ -108035,7 +108035,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) @@ -108054,16 +108054,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 } @@ -108073,7 +108073,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: ; @@ -108089,7 +108089,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 { @@ -108097,7 +108097,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: @@ -108111,7 +108111,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) { @@ -108128,9 +108128,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 } } } @@ -108212,7 +108212,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) @@ -108225,7 +108225,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 @@ -108285,7 +108285,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: @@ -108298,7 +108298,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) @@ -108316,16 +108316,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 } @@ -108335,7 +108335,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: ; @@ -108351,7 +108351,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 { @@ -108359,7 +108359,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: @@ -108373,7 +108373,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) { @@ -108390,9 +108390,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 } } } @@ -108455,7 +108455,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 @@ -108572,8 +108572,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 @@ -108620,7 +108620,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 { @@ -108640,7 +108640,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) { @@ -108678,31 +108678,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): @@ -108726,11 +108726,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))) } } } @@ -108829,10 +108829,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: */ @@ -108877,7 +108877,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 { @@ -108897,7 +108897,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) { @@ -108935,31 +108935,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): @@ -108983,11 +108983,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))) } } } @@ -109137,17 +109137,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 @@ -109169,9 +109169,9 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109179,7 +109179,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109192,19 +109192,19 @@ 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. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) 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 @@ -109251,7 +109251,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) @@ -109277,12 +109277,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) */ @@ -109290,12 +109290,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 @@ -109345,7 +109345,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) @@ -109372,19 +109372,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) { @@ -109486,15 +109486,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 */ @@ -109543,7 +109543,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109587,14 +109587,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) { @@ -109644,15 +109644,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - hi = r * X__log2_data.Finvln2hi - lo = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi) - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(r * X__log2_data.Finvln2hi) + lo = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) + 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 v6 = y @@ -109673,9 +109673,9 @@ func Xlog2(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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109683,7 +109683,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG2_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109697,21 +109697,21 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* log2(x) = log2(z/c) + log2(c) + k. */ /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) - t1 = r * X__log2_data.Finvln2hi - t2 = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) + t1 = Tdouble_t(r * X__log2_data.Finvln2hi) + t2 = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) /* 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 v10 = y goto _11 @@ -109770,7 +109770,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)) } @@ -109792,14 +109792,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 @@ -109861,10 +109861,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)) } @@ -109887,10 +109887,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)) } @@ -109913,10 +109913,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)) } @@ -109960,7 +109960,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)) } @@ -109981,13 +109981,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 @@ -110116,21 +110116,21 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { return x } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } /* no integral part*/ if e < 0 { p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x } - mask = -Uint64FromUint64(1) >> Int32FromInt32(12) >> e + mask = uint64(-Uint64FromUint64(1) >> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = *(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110285,13 +110285,13 @@ _2: if *(*Tuint64_t)(unsafe.Pointer(bp + 8)) == *(*Tuint64_t)(unsafe.Pointer(bp + 16)) { return y3 } - ax = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) - ay = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + ax = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + ay = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) if ax == uint64(0) { if ay == uint64(0) { return y3 } - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1) + *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1)) } else { if ax > ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<<Int32FromInt32(63)) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8))-- @@ -110315,12 +110315,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(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 uint64(8) == uint64(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))) } } } @@ -110415,12 +110415,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110542,12 +110542,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110596,7 +110596,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { tmp = ix - uint64(OFF2) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(POW_LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(POW_LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ @@ -110620,21 +110620,21 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) /* 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. */ hi = t2 + ar2 - lo3 = X__builtin_fma(tls, ar, r, -ar2) + lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* 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 @@ -110657,9 +110657,9 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110667,16 +110667,16 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110694,9 +110694,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 @@ -110741,7 +110741,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 @@ -110751,7 +110751,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). */ @@ -110763,17 +110763,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: @@ -110861,10 +110861,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 } @@ -110924,15 +110924,15 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } } hi = _log_inline(tls, ix, bp) - ehi = y1 * hi - elo = y1**(*Tdouble_t)(unsafe.Pointer(bp)) + X__builtin_fma(tls, y1, hi, -ehi) + ehi = Tdouble_t(y1 * hi) + elo = float64(y1**(*Tdouble_t)(unsafe.Pointer(bp))) + float64(X__builtin_fma(tls, y1, hi, -ehi)) return _exp_inline(tls, ehi, elo, sign_bias) } @@ -110993,16 +110993,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 } @@ -111032,11 +111032,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 @@ -111104,10 +111104,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 } @@ -111138,22 +111138,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) } } @@ -111278,7 +111278,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 @@ -111298,8 +111298,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -111316,9 +111316,9 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } q = uint32(0) if ex < ey { @@ -111368,7 +111368,7 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -111378,7 +111378,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++ } @@ -111451,7 +111451,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 @@ -111549,7 +111549,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++ } @@ -111726,10 +111726,10 @@ func Xround(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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) { @@ -111793,7 +111793,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) { @@ -111847,7 +111847,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)) @@ -111855,7 +111855,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 } @@ -111898,7 +111898,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)) @@ -111906,7 +111906,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 } @@ -111989,10 +111989,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) @@ -112001,7 +112001,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 } @@ -112031,10 +112031,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) @@ -112043,7 +112043,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 } @@ -112225,10 +112225,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 { @@ -112387,10 +112387,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 { @@ -112535,14 +112535,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 } @@ -112583,12 +112583,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 } @@ -112655,7 +112655,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) @@ -112805,7 +112805,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)) } @@ -112938,10 +112938,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 { @@ -113078,18 +113078,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 */ @@ -113150,23 +113150,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 uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113214,12 +113214,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 */ @@ -113315,8 +113315,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: ; @@ -113398,7 +113398,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) @@ -113422,17 +113422,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 } @@ -113483,7 +113483,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if e < int32(12) { e = int32(1) } - m = -Uint64FromUint64(1) >> e + m = uint64(-Uint64FromUint64(1) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&m == uint64(0) { return x3 } @@ -113493,7 +113493,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 @@ -116656,7 +116656,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) @@ -116857,7 +116857,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize *(*Twchar_t)(unsafe.Pointer(wc)) = v1 return BoolUint64(!!(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) @@ -117028,7 +117028,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) @@ -117256,7 +117256,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) @@ -117326,7 +117326,7 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(wc) return uint64(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) @@ -117533,7 +117533,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) @@ -121159,10 +121159,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) + 144 + return uintptr(___get_tp(tls)) + 144 } func Xherror(tls *TLS, msg uintptr) { @@ -127962,7 +127962,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) @@ -134415,7 +134415,7 @@ func Xraise(tls *TLS, sig int32) (r int32) { var _ /* set at bp+0 */ Tsigset_t _ = ret X__block_app_sigs(tls, bp) - ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid), int64(sig))))) + ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid), int64(sig))))) X__restore_sigs(tls, bp) return ret } @@ -135194,13 +135194,13 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r return ret } *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff), + Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff)), Fst_ino: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_ino, Fst_mode: uint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_mode), Fst_nlink: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_nlink, Fst_uid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_uid, Fst_gid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_gid, - Fst_rdev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff), + Fst_rdev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff)), Fst_size: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_size), Fst_blksize: Int32FromUint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_blksize), Fst_blocks: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_blocks), @@ -136469,7 +136469,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -136713,7 +136713,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -136864,7 +136864,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 { @@ -137345,7 +137345,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -137397,7 +137397,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137489,7 +137489,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { var _ /* buf at bp+8 */ [1024]uint8 _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) - ploc = ___get_tp(tls) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -137865,7 +137865,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 @@ -137893,7 +137893,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 } } } @@ -137920,7 +137920,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { var self Tpthread_t var v4 bool _, _, _, _, _, _, _, _ = old, owner, self, tid, tmp, v1, v2, v4 - self = ___get_tp(tls) + self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) if owner & ^Int32FromInt32(MAYBE_WAITERS) == tid { @@ -137983,7 +137983,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) @@ -138201,7 +138201,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -138337,7 +138337,7 @@ func Xgetchar(tls *TLS) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = uintptr(unsafe.Pointer(&X__stdin_FILE)) l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -139065,7 +139065,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -139211,7 +139211,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v1 = c1 v2 = uintptr(unsafe.Pointer(&X__stdout_FILE)) l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -139738,7 +139738,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) + 152 + ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -139990,7 +139990,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -140012,7 +140012,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -140201,7 +140201,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))-- } @@ -140264,7 +140264,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 int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -140317,7 +140317,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) @@ -142167,7 +142167,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -142189,7 +142189,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -144351,7 +144351,7 @@ func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _strtox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _strtox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -144359,7 +144359,7 @@ func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_strtox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_strtox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -144631,7 +144631,7 @@ func Xwcstoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _wcstox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _wcstox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -144639,7 +144639,7 @@ func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_wcstox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_wcstox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xwcstoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -148731,7 +148731,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { n /= uint64(2) } else { a = m @@ -148771,7 +148771,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { } /* If t is before first transition, use the above-found type * and the index-zero (after transition) type as the alt. */ - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) } @@ -149891,7 +149891,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) { @@ -150635,7 +150635,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) { @@ -151713,7 +151713,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)), @@ -151722,7 +151722,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), @@ -153056,12 +153056,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 { Finvc float64 @@ -153715,75 +153715,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))), }, } diff --git a/vendor/modernc.org/libc/ccgo_linux_s390x.go b/vendor/modernc.org/libc/ccgo_linux_s390x.go index 9e6f044b2..998475360 100644 --- a/vendor/modernc.org/libc/ccgo_linux_s390x.go +++ b/vendor/modernc.org/libc/ccgo_linux_s390x.go @@ -553,8 +553,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)) } @@ -606,8 +606,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)) } @@ -810,8 +810,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{ @@ -841,7 +841,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{ @@ -931,7 +931,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(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 } @@ -946,17 +946,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 @@ -983,7 +983,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(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 } @@ -998,17 +998,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 @@ -1129,24 +1129,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 { @@ -1159,15 +1159,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)) } @@ -1185,7 +1185,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)) } @@ -1198,14 +1198,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)) } @@ -1220,7 +1220,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)) } @@ -1236,14 +1236,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)) } @@ -1259,8 +1259,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)) } @@ -1286,24 +1286,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 { @@ -1316,15 +1316,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)) } @@ -1333,48 +1333,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)) } @@ -1475,8 +1475,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)) } @@ -1555,8 +1555,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)) } @@ -1891,18 +1891,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 { @@ -1914,16 +1914,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)) } @@ -1940,7 +1940,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)) @@ -1975,7 +1975,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)) } @@ -1993,14 +1993,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)) } @@ -2016,8 +2016,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)) } @@ -2049,18 +2049,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 { @@ -2072,16 +2072,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)) } @@ -2089,7 +2089,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)) @@ -2111,27 +2111,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)) } @@ -2259,16 +2259,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)) @@ -2375,16 +2375,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)) @@ -2487,7 +2487,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, @@ -2504,7 +2504,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, @@ -2543,18 +2543,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)) @@ -2585,7 +2585,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, @@ -2602,7 +2602,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, @@ -2630,17 +2630,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)) @@ -13902,7 +13902,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) @@ -24981,7 +24981,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 @@ -25017,7 +25017,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * still be detected. Endianness is taken care of * automatically. */ *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) - (*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) { @@ -25627,7 +25627,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) { @@ -26275,19 +26275,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 { @@ -26311,14 +26311,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 */ @@ -26472,7 +26472,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: ; @@ -26498,16 +26498,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)) } } } @@ -26649,10 +26649,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) } } @@ -26688,7 +26688,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 @@ -26717,15 +26717,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) { @@ -26750,7 +26750,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) @@ -28321,7 +28321,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(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -31126,7 +31126,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*8))) + return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31648,7 +31648,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n var _ /* z at bp+8 */ uintptr _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old_cats, old_errno, p1, plural, q, r, rem, rule, trans, v10, v11, v12, v14, v15, v17, v18, v21, 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) { @@ -98301,7 +98301,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) - ploc = ___get_tp(tls) + 168 + ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { return uint64(0) @@ -99335,7 +99335,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) { @@ -100053,7 +100053,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) { @@ -100219,7 +100219,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 } @@ -100294,7 +100294,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 @@ -100383,7 +100383,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)) + 56 if new1 != 0 { @@ -100426,7 +100426,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 @@ -100467,7 +100467,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 @@ -100511,12 +100511,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 @@ -100536,10 +100536,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 @@ -100564,7 +100564,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 @@ -100589,7 +100589,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) { @@ -100787,7 +100787,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: @@ -100810,7 +100810,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: @@ -100891,14 +100891,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) } } @@ -100909,14 +100909,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 { @@ -100924,14 +100924,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) } } @@ -100943,22 +100943,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 @@ -100967,17 +100967,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 } } @@ -101005,7 +101005,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: ; @@ -101185,7 +101185,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: ; @@ -101209,8 +101209,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: @@ -101219,8 +101219,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 @@ -101313,7 +101313,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: ; @@ -101340,8 +101340,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) @@ -101356,7 +101356,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: @@ -101375,7 +101375,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: ; @@ -101566,19 +101566,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 @@ -101675,14 +101675,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 } @@ -101704,11 +101704,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{ @@ -101751,21 +101751,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 { @@ -101786,7 +101786,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 @@ -101809,7 +101809,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 @@ -101824,12 +101824,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 { @@ -101854,8 +101854,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 } @@ -101876,7 +101876,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) } @@ -101887,24 +101887,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 */ @@ -101917,8 +101917,8 @@ var _qS11 = float32(-Float64FromFloat64(0.7066296339)) func _R1(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = float64(z * (_pS01 + z*(_pS11+z*_pS21))) - q = float64(Float32FromFloat32(1) + z*_qS11) + p = Tfloat_t(z * (_pS01 + float32(z*(_pS11+float32(z*_pS21))))) + q = float64(Float32FromFloat32(1) + float32(z*_qS11)) return float32(p / q) } @@ -101936,7 +101936,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) } @@ -101947,24 +101947,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 @@ -101995,11 +101995,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) @@ -102033,11 +102033,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) @@ -102076,8 +102076,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 } @@ -102097,7 +102097,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) } @@ -102107,21 +102107,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 @@ -102140,8 +102140,8 @@ var _qS13 = float32(-Float64FromFloat64(0.7066296339)) func _R3(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = float64(z * (_pS03 + z*(_pS13+z*_pS23))) - q = float64(Float32FromFloat32(1) + z*_qS13) + p = Tfloat_t(z * (_pS03 + float32(z*(_pS13+float32(z*_pS23))))) + q = float64(Float32FromFloat32(1) + float32(z*_qS13)) return float32(p / q) } @@ -102158,7 +102158,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 */ } @@ -102167,12 +102167,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 } @@ -102216,11 +102216,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 uint64(8) == uint64(4) { @@ -102229,7 +102229,7 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } } @@ -102281,11 +102281,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 uint64(4) == uint64(4) { @@ -102411,7 +102411,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)) @@ -102419,7 +102419,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 @@ -102427,15 +102427,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 { @@ -102521,9 +102521,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 { @@ -102638,9 +102638,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 { @@ -102755,7 +102755,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -102772,7 +102772,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)) @@ -102780,7 +102780,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 @@ -102788,15 +102788,15 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } } /* end of argument reduction */ - z = float64(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 * (float64(_aT1[0]) + w*(float64(_aT1[int32(2)])+w*float64(_aT1[int32(4)]))) - s2 = w * (float64(_aT1[int32(1)]) + w*float64(_aT1[int32(3)])) + s1 = Tfloat_t(z * (float64(_aT1[0]) + Tfloat_t(w*(float64(_aT1[int32(2)])+Tfloat_t(w*float64(_aT1[int32(4)])))))) + s2 = Tfloat_t(w * (float64(_aT1[int32(1)]) + Tfloat_t(w*float64(_aT1[int32(3)])))) if id < 0 { - return float32(float64(x3) - float64(x3)*(s1+s2)) + return float32(float64(x3) - Tfloat_t(float64(x3)*(s1+s2))) } - z = float64(_atanhi1[id]) - (float64(x3)*(s1+s2) - float64(_atanlo1[id]) - float64(x3)) + z = float64(_atanhi1[id]) - (Tfloat_t(float64(x3)*(s1+s2)) - float64(_atanlo1[id]) - float64(x3)) if sign != 0 { v4 = -z } else { @@ -102853,11 +102853,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 @@ -102903,22 +102903,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = float32(y3 * y3) + y = float32(Tfloat_t(y3 * y3)) } else { if uint64(4) == uint64(8) { - y1 = float64(float32(y3 * y3)) + y1 = float64(float32(Tfloat_t(y3 * y3))) } else { - y2 = float64(float32(y3 * y3)) + y2 = float64(float32(Tfloat_t(y3 * y3))) } } } } else { /* |x| < 0.5, up to 1.7ulp error */ - y3 = float64(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float64FromInt32(2)*y3+Float64FromInt32(2)*y3*y3/(Float64FromInt32(1)-y3)))) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Tfloat_t(Float64FromInt32(2)*y3)+Tfloat_t(Tfloat_t(Float64FromInt32(2)*y3)*y3)/(Float64FromInt32(1)-y3)))) } } else { /* avoid overflow */ - y3 = float64(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))))) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))))) } if s != 0 { v1 = -y3 @@ -103000,7 +103000,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 @@ -103010,7 +103010,7 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { hx = hx/uint32(3) + _B1 } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103023,8 +103023,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 @@ -103036,14 +103036,14 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * before the final error is larger than 0.667 ulps. */ *(*float64)(unsafe.Pointer(bp)) = t - *(*Tuint64_t)(unsafe.Pointer(bp)) = (*(*Tuint64_t)(unsafe.Pointer(bp)) + Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000) + *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(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 } @@ -103081,7 +103081,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 { @@ -103095,14 +103095,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) } @@ -103288,9 +103288,9 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<<Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } @@ -103363,7 +103363,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(8) { y1 = x3 + Float64FromFloat32(1.329227995784916e+36) } else { - y2 = x3 + Float64FromFloat32(1.329227995784916e+36) + y2 = float64(x3 + Float64FromFloat32(1.329227995784916e+36)) } } return float64(1) @@ -103395,10 +103395,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 { @@ -103528,19 +103528,19 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 */ @@ -103590,12 +103590,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)) @@ -103690,8 +103690,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 } @@ -103704,18 +103704,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) { @@ -103737,13 +103737,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) @@ -103778,14 +103778,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 { @@ -103798,7 +103798,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 } @@ -103875,8 +103875,8 @@ func _erfc11(tls *TLS, x float32) (r float32) { var P, Q, s Tfloat_t _, _, _ = P, Q, s s = float64(Xfabsf(tls, x) - Float32FromInt32(1)) - P = float64(_pa01) + s*(float64(_pa11)+s*(float64(_pa21)+s*(float64(_pa31)+s*(float64(_pa41)+s*(float64(_pa51)+s*float64(_pa61)))))) - Q = Float64FromInt32(1) + s*(float64(_qa11)+s*(float64(_qa21)+s*(float64(_qa31)+s*(float64(_qa41)+s*(float64(_qa51)+s*float64(_qa61)))))) + P = float64(_pa01) + Tfloat_t(s*(float64(_pa11)+Tfloat_t(s*(float64(_pa21)+Tfloat_t(s*(float64(_pa31)+Tfloat_t(s*(float64(_pa41)+Tfloat_t(s*(float64(_pa51)+Tfloat_t(s*float64(_pa61)))))))))))) + Q = Float64FromInt32(1) + Tfloat_t(s*(float64(_qa11)+Tfloat_t(s*(float64(_qa21)+Tfloat_t(s*(float64(_qa31)+Tfloat_t(s*(float64(_qa41)+Tfloat_t(s*(float64(_qa51)+Tfloat_t(s*float64(_qa61)))))))))))) return float32(float64(Float32FromInt32(1)-_erx1) - P/Q) } @@ -103889,18 +103889,18 @@ func _erfc21(tls *TLS, ix Tuint32_t, x float32) (r float32) { return _erfc11(tls, x) } x = Xfabsf(tls, x) - s = float64(Float32FromInt32(1) / (x * x)) + s = float64(Float32FromInt32(1) / float32(x*x)) if ix < uint32(0x4036db6d) { /* |x| < 1/0.35 */ - R = float64(_ra01) + s*(float64(_ra11)+s*(float64(_ra21)+s*(float64(_ra31)+s*(float64(_ra41)+s*(float64(_ra51)+s*(float64(_ra61)+s*float64(_ra71))))))) - S = Float64FromFloat32(1) + s*(float64(_sa11)+s*(float64(_sa21)+s*(float64(_sa31)+s*(float64(_sa41)+s*(float64(_sa51)+s*(float64(_sa61)+s*(float64(_sa71)+s*float64(_sa81)))))))) + R = float64(_ra01) + Tfloat_t(s*(float64(_ra11)+Tfloat_t(s*(float64(_ra21)+Tfloat_t(s*(float64(_ra31)+Tfloat_t(s*(float64(_ra41)+Tfloat_t(s*(float64(_ra51)+Tfloat_t(s*(float64(_ra61)+Tfloat_t(s*float64(_ra71)))))))))))))) + S = Float64FromFloat32(1) + Tfloat_t(s*(float64(_sa11)+Tfloat_t(s*(float64(_sa21)+Tfloat_t(s*(float64(_sa31)+Tfloat_t(s*(float64(_sa41)+Tfloat_t(s*(float64(_sa51)+Tfloat_t(s*(float64(_sa61)+Tfloat_t(s*(float64(_sa71)+Tfloat_t(s*float64(_sa81)))))))))))))))) } else { /* |x| >= 1/0.35 */ - R = float64(_rb01) + s*(float64(_rb11)+s*(float64(_rb21)+s*(float64(_rb31)+s*(float64(_rb41)+s*(float64(_rb51)+s*float64(_rb61)))))) - S = Float64FromFloat32(1) + s*(float64(_sb11)+s*(float64(_sb21)+s*(float64(_sb31)+s*(float64(_sb41)+s*(float64(_sb51)+s*(float64(_sb61)+s*float64(_sb71))))))) + R = float64(_rb01) + Tfloat_t(s*(float64(_rb11)+Tfloat_t(s*(float64(_rb21)+Tfloat_t(s*(float64(_rb31)+Tfloat_t(s*(float64(_rb41)+Tfloat_t(s*(float64(_rb51)+Tfloat_t(s*float64(_rb61)))))))))))) + S = Float64FromFloat32(1) + Tfloat_t(s*(float64(_sb11)+Tfloat_t(s*(float64(_sb21)+Tfloat_t(s*(float64(_sb31)+Tfloat_t(s*(float64(_sb41)+Tfloat_t(s*(float64(_sb51)+Tfloat_t(s*(float64(_sb61)+Tfloat_t(s*float64(_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, float32(float64((z-x)*(z+x))+R/S)) / x + return float32(Xexpf(tls, float32(-z*z)-Float32FromFloat32(0.5625))*Xexpf(tls, float32(Tfloat_t((z-x)*(z+x))+R/S))) / x } func Xerff(tls *TLS, x float32) (r1 float32) { @@ -103922,13 +103922,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) @@ -103963,14 +103963,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 { @@ -103983,7 +103983,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 } @@ -104025,9 +104025,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104035,11 +104035,11 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104056,9 +104056,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 @@ -104109,7 +104109,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 @@ -104119,7 +104119,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)) @@ -104129,17 +104129,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: @@ -104176,8 +104176,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) } @@ -104252,10 +104252,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{ @@ -104315,9 +104315,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = sbits - Uint64FromUint64(1)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104325,11 +104325,11 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -104346,9 +104346,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 @@ -104423,17 +104423,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: @@ -104501,11 +104501,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 @@ -104589,7 +104589,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. */ @@ -104606,11 +104606,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 @@ -104704,10 +104704,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 @@ -104730,42 +104730,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 } @@ -104839,10 +104839,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 = float64(k) - hi = float64(x3) - t*float64(_ln2_hi1) /* t*ln2_hi is exact here */ - lo = t * float64(_ln2_lo1) + hi = float64(x3) - Tfloat_t(t*float64(_ln2_hi1)) /* t*ln2_hi is exact here */ + lo = Tfloat_t(t * float64(_ln2_lo1)) } x3 = float32(hi - lo) c = hi - float64(x3) - lo @@ -104850,7 +104850,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -104865,42 +104865,42 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { } } /* x is now in primary range */ - hfx = float64(Float32FromFloat32(0.5) * x3) - hxs = float64(x3) * hfx - r1 = Float64FromFloat32(1) + hxs*(float64(_Q11)+hxs*float64(_Q21)) - t = Float64FromFloat32(3) - r1*hfx - e = hxs * ((r1 - t) / (Float64FromFloat32(6) - float64(x3)*t)) + hfx = Tfloat_t(Float32FromFloat32(0.5) * x3) + hxs = Tfloat_t(float64(x3) * hfx) + r1 = Float64FromFloat32(1) + Tfloat_t(hxs*(float64(_Q11)+Tfloat_t(hxs*float64(_Q21)))) + t = Float64FromFloat32(3) - Tfloat_t(r1*hfx) + e = Tfloat_t(hxs * ((r1 - t) / (Float64FromFloat32(6) - Tfloat_t(float64(x3)*t)))) if k == 0 { /* c is 0 */ - return float32(float64(x3) - (float64(x3)*e - hxs)) + return float32(float64(x3) - (Tfloat_t(float64(x3)*e) - hxs)) } - e = float64(x3)*(e-c) - c + e = Tfloat_t(float64(x3)*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return float32(Float64FromFloat32(0.5)*(float64(x3)-e) - Float64FromFloat32(0.5)) + return float32(Tfloat_t(Float64FromFloat32(0.5)*(float64(x3)-e)) - Float64FromFloat32(0.5)) } if k == int32(1) { if x3 < -Float32FromFloat32(0.25) { return float32(float64(-Float32FromFloat32(2)) * (e - float64(x3+Float32FromFloat32(0.5)))) } - return float32(Float64FromFloat32(1) + Float64FromFloat32(2)*(float64(x3)-e)) + return float32(Float64FromFloat32(1) + Tfloat_t(Float64FromFloat32(2)*(float64(x3)-e))) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) + k) << int32(23)) /* 2^k */ twopk = float64(*(*float32)(unsafe.Pointer(bp))) if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */ y3 = float64(x3) - e + Float64FromFloat32(1) if k == int32(128) { - y3 = y3 * Float64FromFloat32(2) * Float64FromFloat32(1.7014118346046923e+38) + y3 = Tfloat_t(Tfloat_t(y3*Float64FromFloat32(2)) * Float64FromFloat32(1.7014118346046923e+38)) } else { - y3 = y3 * twopk + y3 = Tfloat_t(y3 * twopk) } return float32(y3 - Float64FromFloat32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) - k) << int32(23)) /* 2^-k */ if k < int32(23) { - y3 = (float64(x3) - e + float64(Float32FromInt32(1)-*(*float32)(unsafe.Pointer(bp)))) * twopk + y3 = Tfloat_t((float64(x3) - e + float64(Float32FromInt32(1)-*(*float32)(unsafe.Pointer(bp)))) * twopk) } else { - y3 = (float64(x3) - (e + float64(*(*float32)(unsafe.Pointer(bp)))) + Float64FromInt32(1)) * twopk + y3 = Tfloat_t((float64(x3) - (e + float64(*(*float32)(unsafe.Pointer(bp)))) + Float64FromInt32(1)) * twopk) } return float32(y3) } @@ -104935,7 +104935,7 @@ func Xfabs(tls *TLS, x float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105249,7 +105249,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 { @@ -105259,8 +105259,8 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1)) - ix = ix | Uint64FromUint64(1)<<Int32FromInt32(52) + ix = Tuint64_t(ix & (Uint64FromUint64(1)<<Int32FromInt32(52) - Uint64FromInt32(1))) + ix = Tuint64_t(ix | Uint64FromUint64(1)<<Int32FromInt32(52)) ix <<= uint64(1) e -= Int32FromInt32(0x3ff) + Int32FromInt32(52) + Int32FromInt32(1) return Tnum{ @@ -105306,11 +105306,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { ny = _normalize(tls, y1) 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*y1 + z + return float64(x1*y1) + 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*y1 + z + return float64(x1*y1) + z } return z } @@ -105451,7 +105451,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } } else { /* exact +-0 */ - return x1*y1 + z + return float64(x1*y1) + z } } e -= d @@ -105472,8 +105472,8 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 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) * r1) - return Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin) + fltmin = float32(float64(Float64FromFloat64(1.0842021401737618e-19)*Float64FromFloat32(1.1754943508222875e-38)) * r1) + 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 */ @@ -105483,11 +105483,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { i = -i } r1 = float64(i) - r1 = Float64FromInt32(2)*r1 - c /* remove top bit */ + r1 = float64(Float64FromInt32(2)*r1) - c /* remove top bit */ /* raise underflow portably, such that it cannot be optimized away */ - tiny = Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1 - r1 += tiny * tiny * (r1 - r1) + tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1) + r1 += float64(Tdouble_t(tiny*tiny) * (r1 - r1)) } } else { /* only round once when scaled */ @@ -105811,11 +105811,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 } @@ -105834,8 +105834,8 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -105852,9 +105852,9 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } /* x mod y */ for { @@ -105864,7 +105864,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 } @@ -105877,7 +105877,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 } @@ -105893,7 +105893,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { } /* scale result */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -105954,11 +105954,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 } @@ -106005,7 +106005,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 } @@ -106018,7 +106018,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 } @@ -106077,7 +106077,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 @@ -106090,9 +106090,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106153,11 +106153,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) { @@ -106205,9 +106205,9 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106258,7 +106258,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) { @@ -106337,7 +106337,7 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { y *= Float32FromFloat32(1.2379400392853803e+27) } } - return float32(z * float64(Xsqrtf(tls, float32(float64(x)*float64(x)+float64(y)*float64(y))))) + return float32(z * float64(Xsqrtf(tls, float32(float64(float64(x)*float64(x))+float64(float64(y)*float64(y)))))) } func Xhypotl(tls *TLS, x float64, y float64) (r float64) { @@ -106530,8 +106530,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 @@ -106540,10 +106540,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 @@ -106571,7 +106571,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 */ @@ -106581,16 +106581,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 } @@ -106636,12 +106636,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 @@ -106742,9 +106742,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 } @@ -106850,9 +106850,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 } @@ -106874,8 +106874,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 @@ -106884,10 +106884,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 @@ -106914,7 +106914,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 */ @@ -106923,13 +106923,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 } @@ -106970,12 +106970,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 @@ -107075,9 +107075,9 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 4*4))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -107183,9 +107183,9 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) return float32((float64(-Float32FromFloat32(0.125)) + r/s) / float64(x)) } @@ -107212,8 +107212,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 @@ -107222,13 +107222,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 @@ -107258,21 +107258,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{ @@ -107318,10 +107318,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 @@ -107421,9 +107421,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 } @@ -107528,9 +107528,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 } @@ -107548,8 +107548,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 @@ -107558,13 +107558,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 @@ -107594,20 +107594,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{ @@ -107649,10 +107649,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 @@ -107752,9 +107752,9 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 4*4))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -107859,9 +107859,9 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } } - z = float64(Float32FromFloat32(1) / (x * x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(p + 5*4))))))) - s = Float64FromFloat32(1) + z*(float64(*(*float32)(unsafe.Pointer(q)))+z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))) + z = float64(Float32FromFloat32(1) / float32(x*x)) + r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) return float32((Float64FromFloat32(0.375) + r/s) / float64(x)) } @@ -107936,7 +107936,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) @@ -107947,7 +107947,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: @@ -107961,7 +107961,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) @@ -107980,16 +107980,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 } @@ -107999,7 +107999,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: ; @@ -108015,7 +108015,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 { @@ -108023,7 +108023,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: @@ -108037,7 +108037,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) { @@ -108054,9 +108054,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 } } } @@ -108138,7 +108138,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) @@ -108151,7 +108151,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 @@ -108211,7 +108211,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: @@ -108224,7 +108224,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) @@ -108242,16 +108242,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 } @@ -108261,7 +108261,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: ; @@ -108277,7 +108277,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 { @@ -108285,7 +108285,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: @@ -108299,7 +108299,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) { @@ -108316,9 +108316,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 } } } @@ -108381,7 +108381,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 @@ -108498,8 +108498,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 @@ -108546,7 +108546,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 { @@ -108566,7 +108566,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) { @@ -108604,31 +108604,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): @@ -108652,11 +108652,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))) } } } @@ -108755,10 +108755,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: */ @@ -108803,7 +108803,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 { @@ -108823,7 +108823,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) { @@ -108861,31 +108861,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): @@ -108909,11 +108909,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))) } } } @@ -109048,17 +109048,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 @@ -109080,9 +109080,9 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109090,7 +109090,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109103,19 +109103,19 @@ 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. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) 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 @@ -109162,7 +109162,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) @@ -109188,12 +109188,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) */ @@ -109201,12 +109201,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 @@ -109256,7 +109256,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) @@ -109283,19 +109283,19 @@ func Xlog10f(tls *TLS, x float32) (r float32) { x = *(*float32)(unsafe.Pointer(bp)) f = float64(x - Float32FromFloat32(1)) s = f / (Float64FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (float64(_Lg21) + w*float64(_Lg41)) - t2 = z * (float64(_Lg11) + w*float64(_Lg31)) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (float64(_Lg21) + Tfloat_t(w*float64(_Lg41)))) + t2 = Tfloat_t(z * (float64(_Lg11) + Tfloat_t(w*float64(_Lg31)))) R = t2 + t1 - hfsq = Float64FromFloat32(0.5) * f * f + hfsq = Tfloat_t(Tfloat_t(Float64FromFloat32(0.5)*f) * f) hi = f - hfsq *(*float32)(unsafe.Pointer(bp)) = float32(hi) *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0xfffff000) hi = float64(*(*float32)(unsafe.Pointer(bp))) - lo = f - hi - hfsq + s*(hfsq+R) + lo = f - hi - hfsq + Tfloat_t(s*(hfsq+R)) dk = float64(k) - return float32(dk*float64(_log10_2lo1) + (lo+hi)*float64(_ivln10lo1) + lo*float64(_ivln10hi1) + hi*float64(_ivln10hi1) + dk*float64(_log10_2hi1)) + return float32(Tfloat_t(dk*float64(_log10_2lo1)) + Tfloat_t((lo+hi)*float64(_ivln10lo1)) + Tfloat_t(lo*float64(_ivln10hi1)) + Tfloat_t(hi*float64(_ivln10hi1)) + Tfloat_t(dk*float64(_log10_2hi1))) } func Xlog10l(tls *TLS, x float64) (r float64) { @@ -109397,15 +109397,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 */ @@ -109454,7 +109454,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109498,14 +109498,14 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { f = float64(*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } s = f / (Float64FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (float64(_Lg23) + w*float64(_Lg43)) - t2 = z * (float64(_Lg13) + w*float64(_Lg33)) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (float64(_Lg23) + Tfloat_t(w*float64(_Lg43)))) + t2 = Tfloat_t(z * (float64(_Lg13) + Tfloat_t(w*float64(_Lg33)))) R = t2 + t1 - hfsq = Float64FromFloat32(0.5) * f * f + hfsq = Tfloat_t(Tfloat_t(Float64FromFloat32(0.5)*f) * f) dk = float64(k) - return float32(s*(hfsq+R) + (dk*float64(_ln2_lo3) + c) - hfsq + f + dk*float64(_ln2_hi3)) + return float32(Tfloat_t(s*(hfsq+R)) + (Tfloat_t(dk*float64(_ln2_lo3)) + c) - hfsq + f + Tfloat_t(dk*float64(_ln2_hi3))) } func Xlog1pl(tls *TLS, x float64) (r float64) { @@ -109555,15 +109555,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - hi = r * X__log2_data.Finvln2hi - lo = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi) - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(r * X__log2_data.Finvln2hi) + lo = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) + 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 v6 = y @@ -109584,9 +109584,9 @@ func Xlog2(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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. The range is split into N subintervals. @@ -109594,7 +109594,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { tmp = ix - uint64(OFF) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(LOG2_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) invc = (*(*struct { Finvc float64 Flogc float64 @@ -109608,21 +109608,21 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* log2(x) = log2(z/c) + log2(c) + k. */ /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) - t1 = r * X__log2_data.Finvln2hi - t2 = r*X__log2_data.Finvln2lo + X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) + t1 = Tdouble_t(r * X__log2_data.Finvln2hi) + t2 = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) /* 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 v10 = y goto _11 @@ -109681,7 +109681,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)) } @@ -109703,14 +109703,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 @@ -109772,10 +109772,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)) } @@ -109798,10 +109798,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)) } @@ -109824,10 +109824,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)) } @@ -109871,7 +109871,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)) } @@ -109892,13 +109892,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 @@ -110027,21 +110027,21 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { return x } p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = *(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } /* no integral part*/ if e < 0 { p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = *(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x } - mask = -Uint64FromUint64(1) >> Int32FromInt32(12) >> e + mask = uint64(-Uint64FromUint64(1) >> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = *(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63)) + *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110196,13 +110196,13 @@ _2: if *(*Tuint64_t)(unsafe.Pointer(bp + 8)) == *(*Tuint64_t)(unsafe.Pointer(bp + 16)) { return y3 } - ax = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) - ay = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2)) + ax = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + ay = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) if ax == uint64(0) { if ay == uint64(0) { return y3 } - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1) + *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)<<Int32FromInt32(63)) | uint64(1)) } else { if ax > ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<<Int32FromInt32(63)) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8))-- @@ -110226,12 +110226,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(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 uint64(8) == uint64(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))) } } } @@ -110326,12 +110326,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110453,12 +110453,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(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 uint64(4) == uint64(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)))) } } } @@ -110507,7 +110507,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { tmp = ix - uint64(OFF2) i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(POW_LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(POW_LOG_TABLE_BITS))) k = int32(Int64FromUint64(tmp) >> int32(52)) /* arithmetic shift */ - iz = ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52)) + iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)<<Int32FromInt32(52))) z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ @@ -110531,21 +110531,21 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ - r = X__builtin_fma(tls, z, invc, -Float64FromFloat64(1)) + r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) /* 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. */ hi = t2 + ar2 - lo3 = X__builtin_fma(tls, ar, r, -ar2) + lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* 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 @@ -110568,9 +110568,9 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = sbits - Uint64FromUint64(1009)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110578,16 +110578,16 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl return v1 } /* k < 0, need special care in the subnormal range. */ - sbits = sbits + Uint64FromUint64(1022)<<Int32FromInt32(52) + sbits = Tuint64_t(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 @@ -110605,9 +110605,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 @@ -110652,7 +110652,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 @@ -110662,7 +110662,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). */ @@ -110674,17 +110674,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: @@ -110772,10 +110772,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 } @@ -110835,15 +110835,15 @@ 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 = ix - Uint64FromUint64(52)<<Int32FromInt32(52) + ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } } hi = _log_inline(tls, ix, bp) - ehi = y1 * hi - elo = y1**(*Tdouble_t)(unsafe.Pointer(bp)) + X__builtin_fma(tls, y1, hi, -ehi) + ehi = Tdouble_t(y1 * hi) + elo = float64(y1**(*Tdouble_t)(unsafe.Pointer(bp))) + float64(X__builtin_fma(tls, y1, hi, -ehi)) return _exp_inline(tls, ehi, elo, sign_bias) } @@ -110904,16 +110904,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 } @@ -110943,11 +110943,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 @@ -111015,10 +111015,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 = float64(x1 * x1) + x2 = Tfloat_t(x1 * x1) if ix&uint32(0x80000000) != 0 && _checkint1(tls, iy) == int32(1) { x2 = -x2 } @@ -111049,22 +111049,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) } } @@ -111189,7 +111189,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 @@ -111209,8 +111209,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { } uxi <<= Uint64FromInt32(-ex + int32(1)) } else { - uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) - uxi = uxi | Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) + uxi = Tuint64_t(uxi | Uint64FromUint64(1)<<Int32FromInt32(52)) } if !(ey != 0) { i = *(*Tuint64_t)(unsafe.Pointer(bp + 16)) << int32(12) @@ -111227,9 +111227,9 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp + 16)) <<= Uint64FromInt32(-ey + int32(1)) } else { p6 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p6)) = *(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + *(*Tuint64_t)(unsafe.Pointer(p6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p6)) & (-Uint64FromUint64(1) >> Int32FromInt32(12))) p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = *(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52) + *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<<Int32FromInt32(52)) } q = uint32(0) if ex < ey { @@ -111279,7 +111279,7 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = uxi - Uint64FromUint64(1)<<Int32FromInt32(52) + uxi = Tuint64_t(uxi - Uint64FromUint64(1)<<Int32FromInt32(52)) uxi |= Uint64FromInt32(ex) << int32(52) } else { uxi >>= Uint64FromInt32(-ex + int32(1)) @@ -111289,7 +111289,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++ } @@ -111362,7 +111362,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 @@ -111460,7 +111460,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++ } @@ -111637,10 +111637,10 @@ func Xround(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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) { @@ -111704,7 +111704,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 = float64(x3) + _toint7 - _toint7 - float64(x3) if y3 > Float64FromFloat32(0.5) { @@ -111758,7 +111758,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)) @@ -111766,7 +111766,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 } @@ -111809,7 +111809,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)) @@ -111817,7 +111817,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 } @@ -111900,10 +111900,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) @@ -111912,7 +111912,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 } @@ -111942,10 +111942,10 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { } } else { if n < -int32(126) { - y *= float64(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 *= float64(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) @@ -112136,10 +112136,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 { @@ -112298,10 +112298,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 { @@ -112446,14 +112446,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 } @@ -112494,12 +112494,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 } @@ -112566,7 +112566,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) @@ -112716,7 +112716,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)) } @@ -112849,10 +112849,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 { @@ -112989,18 +112989,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 */ @@ -113061,23 +113061,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 uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113125,12 +113125,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 */ @@ -113226,8 +113226,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: ; @@ -113309,7 +113309,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) @@ -113333,17 +113333,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 } @@ -113394,7 +113394,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if e < int32(12) { e = int32(1) } - m = -Uint64FromUint64(1) >> e + m = uint64(-Uint64FromUint64(1) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&m == uint64(0) { return x3 } @@ -113404,7 +113404,7 @@ func Xtrunc(tls *TLS, x3 float64) (r float64) { if uint64(8) == uint64(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 @@ -116563,7 +116563,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) @@ -116764,7 +116764,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize *(*Twchar_t)(unsafe.Pointer(wc)) = v1 return BoolUint64(!!(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) @@ -116935,7 +116935,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) @@ -117163,7 +117163,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) @@ -117233,7 +117233,7 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(wc) return uint64(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) @@ -117440,7 +117440,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) @@ -121276,10 +121276,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) + 160 + return uintptr(___get_tp(tls)) + 160 } func Xherror(tls *TLS, msg uintptr) { @@ -128385,7 +128385,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) @@ -134834,7 +134834,7 @@ func Xraise(tls *TLS, sig int32) (r int32) { var _ /* set at bp+0 */ Tsigset_t _ = ret X__block_app_sigs(tls, bp) - ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(___get_tp(tls))).Ftid), int64(sig))))) + ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_tkill), int64((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Ftid), int64(sig))))) X__restore_sigs(tls, bp) return ret } @@ -135625,13 +135625,13 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r return ret } *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff), + Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_minor)&Uint64FromUint64(0x000000ff)), Fst_ino: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_ino, Fst_nlink: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_nlink), Fst_mode: uint32((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_mode), Fst_uid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_uid, Fst_gid: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_gid, - Fst_rdev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff), + Fst_rdev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0xfffff000)<<Int32FromInt32(32) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_major)&Uint64FromUint64(0x00000fff)<<Int32FromInt32(8) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0xffffff00)<<Int32FromInt32(12) | uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_rdev_minor)&Uint64FromUint64(0x000000ff)), Fst_size: Int64FromUint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_size), Fst_atim: Ttimespec{ Ftv_sec: (*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_atime.Ftv_sec, @@ -136938,7 +136938,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -137182,7 +137182,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) + 168 + ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137333,7 +137333,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 { @@ -137812,7 +137812,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -137864,7 +137864,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) + 168 + ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) @@ -137956,7 +137956,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { var _ /* buf at bp+8 */ [1024]uint8 _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) - ploc = ___get_tp(tls) + 168 + ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138332,7 +138332,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 @@ -138360,7 +138360,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 } } } @@ -138387,7 +138387,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { var self Tpthread_t var v5 bool _, _, _, _, _, _, _ = 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 + 140) if owner & ^Int32FromInt32(MAYBE_WAITERS) == tid { @@ -138449,7 +138449,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) @@ -138665,7 +138665,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = f1 l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -138799,7 +138799,7 @@ func Xgetchar(tls *TLS) (r int32) { _, _, _, _, _, _ = l, v1, v2, v4, v5, v6 v1 = uintptr(unsafe.Pointer(&X__stdin_FILE)) l = AtomicLoadPInt32(v1 + 140) - 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 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) @@ -139525,7 +139525,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v1 = c1 v2 = f1 l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -139669,7 +139669,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v1 = c1 v2 = uintptr(unsafe.Pointer(&X__stdout_FILE)) l = AtomicLoadPInt32(v2 + 140) - 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 + 40 @@ -140196,7 +140196,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) + 168 + ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -140448,7 +140448,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -140470,7 +140470,7 @@ func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -140659,7 +140659,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))-- } @@ -140722,7 +140722,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 int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -140775,7 +140775,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) @@ -142625,7 +142625,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_ULONG): (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) case int32(_SHORT): (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) case int32(_USHORT): @@ -142647,7 +142647,7 @@ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { case int32(_UIPTR): (*Targ)(unsafe.Pointer(arg)).Fi = uint64(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))) } @@ -144818,7 +144818,7 @@ func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _strtox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _strtox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -144826,7 +144826,7 @@ func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_strtox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_strtox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -145098,7 +145098,7 @@ func Xwcstoul(tls *TLS, s uintptr, p uintptr, base int32) (r uint64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return _wcstox1(tls, s, p, base, Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) + return _wcstox1(tls, s, p, base, uint64(Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))) } func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { @@ -145106,7 +145106,7 @@ func Xwcstol(tls *TLS, s uintptr, p uintptr, base int32) (r int64) { trc("tls=%v s=%v p=%v base=%v, (%v:)", tls, s, p, base, origin(2)) defer func() { trc("-> %v", r) }() } - return Int64FromUint64(_wcstox1(tls, s, p, base, Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1)))) + return Int64FromUint64(_wcstox1(tls, s, p, base, uint64(Uint64FromUint64(0)+Uint64FromInt64(-Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1))))) } func Xwcstoimax(tls *TLS, s uintptr, p uintptr, base int32) (r Tintmax_t) { @@ -149198,7 +149198,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { n /= uint64(2) } else { a = m @@ -149238,7 +149238,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { } /* If t is before first transition, use the above-found type * and the index-zero (after transition) type as the alt. */ - if t-int64(off) < Int64FromUint64(x) { + if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) } @@ -150359,7 +150359,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) { @@ -151103,7 +151103,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) { @@ -152195,7 +152195,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)), @@ -152204,7 +152204,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), @@ -153538,12 +153538,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 { Finvc float64 @@ -154197,75 +154197,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))), }, } diff --git a/vendor/modernc.org/libc/etc.go b/vendor/modernc.org/libc/etc.go index 2d76cc499..db01023dd 100644 --- a/vendor/modernc.org/libc/etc.go +++ b/vendor/modernc.org/libc/etc.go @@ -237,6 +237,7 @@ func (t *TLS) Close() { // t.Free(11) // t.Free(22) func (t *TLS) Alloc(n int) (r uintptr) { + t.sp++ if memgrind { if atomic.SwapInt32(&t.reentryGuard, 1) != 0 { panic(todo("concurrent use of TLS instance %p", t)) @@ -321,6 +322,7 @@ const stackFrameKeepalive = 2 // Free deallocates n bytes of thread-local storage. See TLS.Alloc for details // on correct usage. func (t *TLS) Free(n int) { + t.sp-- if memgrind { if atomic.SwapInt32(&t.reentryGuard, 1) != 0 { panic(todo("concurrent use of TLS instance %p", t)) diff --git a/vendor/modernc.org/libc/libc.go b/vendor/modernc.org/libc/libc.go index 2a7988bd4..dab50ebf3 100644 --- a/vendor/modernc.org/libc/libc.go +++ b/vendor/modernc.org/libc/libc.go @@ -4,11 +4,9 @@ //go:build !linux || mips64le -//go.generate echo package libc > ccgo.go -//go:generate go fmt ./... - -// Package libc provides run time support for ccgo generated programs and -// implements selected parts of the C standard library. +// go.generate echo package libc > ccgo.go +// +//go:generate go fmt -l -s -w ./... package libc // import "modernc.org/libc" //TODO use O_RDONLY etc. from fcntl header @@ -1952,7 +1950,7 @@ func getLocalLocation() (loc *gotime.Location) { } // time_t mktime(struct tm *tm); -func Xmktime(t *TLS, ptm uintptr) time.Time_t { +func Xmktime(t *TLS, ptm uintptr) (r time.Time_t) { if __ccgo_strace { trc("t=%v ptm=%v, (%v:)", t, ptm, origin(2)) } @@ -1969,7 +1967,8 @@ func Xmktime(t *TLS, ptm uintptr) time.Time_t { ) (*time.Tm)(unsafe.Pointer(ptm)).Ftm_wday = int32(tt.Weekday()) (*time.Tm)(unsafe.Pointer(ptm)).Ftm_yday = int32(tt.YearDay() - 1) - return time.Time_t(tt.Unix()) + r = time.Time_t(tt.Unix()) + return r } // char *strpbrk(const char *s, const char *accept); @@ -2314,14 +2313,6 @@ func Xwcwidth(t *TLS, c wchar_t) int32 { panic(todo("")) } -// int clock_gettime(clockid_t clk_id, struct timespec *tp); -func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32 { - if __ccgo_strace { - trc("t=%v clk_id=%v tp=%v, (%v:)", t, clk_id, tp, origin(2)) - } - panic(todo("")) -} - // AtExit will attempt to run f at process exit. The execution cannot be // guaranteed, neither its ordering with respect to any other handlers // registered by AtExit. @@ -2650,3 +2641,933 @@ func Xlrint(tls *TLS, x float64) (r long) { } return long(Xrint(tls, x)) } + +func X__builtin_trunc(tls *TLS, x float64) (r float64) { + return Xtrunc(tls, x) +} + +func X__builtin_fmin(tls *TLS, x float64, y float64) (r float64) { + return Xfmin(tls, x, y) +} + +func Xfmin(tls *TLS, x float64, y float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var v1, v10, v3, v5, v7 uint64 + var v12, v9 float64 + var _ /* __u at bp+0 */ struct { + F__i [0]uint64 + F__f float64 + } + _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + *(*float64)(unsafe.Pointer(bp)) = x + v1 = *(*uint64)(unsafe.Pointer(bp)) + goto _2 +_2: + if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { + return y + } + *(*float64)(unsafe.Pointer(bp)) = y + v3 = *(*uint64)(unsafe.Pointer(bp)) + goto _4 +_4: + if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { + return x + } + /* handle signed zeros, see C99 Annex F.9.9.2 */ + *(*float64)(unsafe.Pointer(bp)) = x + v5 = *(*uint64)(unsafe.Pointer(bp)) + goto _6 +_6: + *(*float64)(unsafe.Pointer(bp)) = y + v7 = *(*uint64)(unsafe.Pointer(bp)) + goto _8 +_8: + if Int32FromUint64(v5>>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + *(*float64)(unsafe.Pointer(bp)) = x + v10 = *(*uint64)(unsafe.Pointer(bp)) + goto _11 + _11: + if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + v9 = x + } else { + v9 = y + } + return v9 + } + if x < y { + v12 = x + } else { + v12 = y + } + return v12 +} + +func Xfminf(tls *TLS, x float32, y float32) (r float32) { + if __ccgo_strace { + trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var v1, v10, v3, v5, v7 uint32 + var v12, v9 float32 + var _ /* __u at bp+0 */ struct { + F__i [0]uint32 + F__f float32 + } + _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + *(*float32)(unsafe.Pointer(bp)) = x + v1 = *(*uint32)(unsafe.Pointer(bp)) + goto _2 +_2: + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + return y + } + *(*float32)(unsafe.Pointer(bp)) = y + v3 = *(*uint32)(unsafe.Pointer(bp)) + goto _4 +_4: + if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + return x + } + /* handle signed zeros, see C99 Annex F.9.9.2 */ + *(*float32)(unsafe.Pointer(bp)) = x + v5 = *(*uint32)(unsafe.Pointer(bp)) + goto _6 +_6: + *(*float32)(unsafe.Pointer(bp)) = y + v7 = *(*uint32)(unsafe.Pointer(bp)) + goto _8 +_8: + if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + *(*float32)(unsafe.Pointer(bp)) = x + v10 = *(*uint32)(unsafe.Pointer(bp)) + goto _11 + _11: + if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + v9 = x + } else { + v9 = y + } + return v9 + } + if x < y { + v12 = x + } else { + v12 = y + } + return v12 +} + +func Xfminl(tls *TLS, x float64, y float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2)) + defer func() { trc("-> %v", r) }() + } + return Xfmin(tls, x, y) +} + +func Xfmax(tls *TLS, x float64, y float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var v1, v10, v3, v5, v7 uint64 + var v12, v9 float64 + var _ /* __u at bp+0 */ struct { + F__i [0]uint64 + F__f float64 + } + _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + *(*float64)(unsafe.Pointer(bp)) = x + v1 = *(*uint64)(unsafe.Pointer(bp)) + goto _2 +_2: + if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { + return y + } + *(*float64)(unsafe.Pointer(bp)) = y + v3 = *(*uint64)(unsafe.Pointer(bp)) + goto _4 +_4: + if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { + return x + } + /* handle signed zeros, see C99 Annex F.9.9.2 */ + *(*float64)(unsafe.Pointer(bp)) = x + v5 = *(*uint64)(unsafe.Pointer(bp)) + goto _6 +_6: + *(*float64)(unsafe.Pointer(bp)) = y + v7 = *(*uint64)(unsafe.Pointer(bp)) + goto _8 +_8: + if Int32FromUint64(v5>>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + *(*float64)(unsafe.Pointer(bp)) = x + v10 = *(*uint64)(unsafe.Pointer(bp)) + goto _11 + _11: + if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + v9 = y + } else { + v9 = x + } + return v9 + } + if x < y { + v12 = y + } else { + v12 = x + } + return v12 +} + +func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { + if __ccgo_strace { + trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var v1, v10, v3, v5, v7 uint32 + var v12, v9 float32 + var _ /* __u at bp+0 */ struct { + F__i [0]uint32 + F__f float32 + } + _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + *(*float32)(unsafe.Pointer(bp)) = x + v1 = *(*uint32)(unsafe.Pointer(bp)) + goto _2 +_2: + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + return y + } + *(*float32)(unsafe.Pointer(bp)) = y + v3 = *(*uint32)(unsafe.Pointer(bp)) + goto _4 +_4: + if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + return x + } + /* handle signed zeroes, see C99 Annex F.9.9.2 */ + *(*float32)(unsafe.Pointer(bp)) = x + v5 = *(*uint32)(unsafe.Pointer(bp)) + goto _6 +_6: + *(*float32)(unsafe.Pointer(bp)) = y + v7 = *(*uint32)(unsafe.Pointer(bp)) + goto _8 +_8: + if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + *(*float32)(unsafe.Pointer(bp)) = x + v10 = *(*uint32)(unsafe.Pointer(bp)) + goto _11 + _11: + if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + v9 = y + } else { + v9 = x + } + return v9 + } + if x < y { + v12 = y + } else { + v12 = x + } + return v12 +} + +func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2)) + defer func() { trc("-> %v", r) }() + } + return Xfmax(tls, x, y) +} + +func X__builtin_fmax(tls *TLS, x float64, y float64) (r float64) { + return Xfmax(tls, x, y) +} + +func Xexpm1(tls *TLS, x3 float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var c, e, hfx, hi, hxs, lo, r1, t, twopk, y3 Tdouble_t + var hx Tuint32_t + var k, sign int32 + var y float32 + var y1, y2, v3 float64 + var v1 uint64 + var _ /* __u at bp+0 */ struct { + F__i [0]uint64 + F__f float64 + } + var _ /* u at bp+8 */ struct { + Fi [0]Tuint64_t + Ff float64 + } + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, e, hfx, hi, hx, hxs, k, lo, r1, sign, t, twopk, y, y1, y2, y3, v1, v3 + *(*struct { + Fi [0]Tuint64_t + Ff float64 + })(unsafe.Pointer(bp + 8)) = struct { + Fi [0]Tuint64_t + Ff float64 + }{} + *(*float64)(unsafe.Pointer(bp + 8)) = x3 + hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) >> int32(32) & uint64(0x7fffffff)) + sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) >> int32(63)) + /* filter out huge and non-finite argument */ + if hx >= uint32(0x4043687A) { /* if |x|>=56*ln2 */ + *(*float64)(unsafe.Pointer(bp)) = x3 + v1 = *(*uint64)(unsafe.Pointer(bp)) + goto _2 + _2: + if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { + return x3 + } + if sign != 0 { + return float64(-Int32FromInt32(1)) + } + if x3 > _o_threshold { + x3 *= float64(8.98846567431158e+307) + return x3 + } + } + /* argument reduction */ + if hx > uint32(0x3fd62e42) { /* if |x| > 0.5 ln2 */ + if hx < uint32(0x3FF0A2B2) { /* and |x| < 1.5 ln2 */ + if !(sign != 0) { + hi = x3 - _ln2_hi + lo = _ln2_lo + k = int32(1) + } else { + hi = x3 + _ln2_hi + lo = -_ln2_lo + k = -int32(1) + } + } else { + if sign != 0 { + v3 = -Float64FromFloat64(0.5) + } else { + v3 = float64(0.5) + } + k = int32(float64(_invln2*x3) + v3) + t = float64(k) + 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 + } else { + if hx < uint32(0x3c900000) { /* |x| < 2**-54, return x */ + if hx < uint32(0x00100000) { + if uint64(4) == uint64(4) { + y = float32(x3) + } else { + if uint64(4) == uint64(8) { + y1 = float64(float32(x3)) + } else { + y2 = float64(float32(x3)) + } + } + } + return x3 + } else { + k = 0 + } + } + /* x is now in primary range */ + 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 - (float64(x3*e) - hxs) + } + e = float64(x3*(e-c)) - c + e -= hxs + /* exp(x) ~ 2^k (Xreduced - e + 1) */ + if k == -int32(1) { + return float64(float64(0.5)*(x3-e)) - float64(0.5) + } + if k == int32(1) { + if x3 < -Float64FromFloat64(0.25) { + return float64(-Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5)))) + } + 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 = Tdouble_t(Tdouble_t(y3*float64(2)) * float64(8.98846567431158e+307)) + } else { + 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 = Tdouble_t((x3 - e + (Float64FromInt32(1) - *(*float64)(unsafe.Pointer(bp + 8)))) * twopk) + } else { + y3 = Tdouble_t((x3 - (e + *(*float64)(unsafe.Pointer(bp + 8))) + Float64FromInt32(1)) * twopk) + } + return y3 +} + +var _ln2_hi1 = float32(0.69313812256) /* 0x3f317180 */ +var _ln2_lo1 = float32(9.0580006145e-06) /* 0x3717f7d1 */ +var _invln21 = float32(1.4426950216) /* 0x3fb8aa3b */ +/* + * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]: + * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04 + * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c): + */ +var _Q11 = float32(-Float64FromFloat64(0.033333212137)) /* -0x888868.0p-28 */ +var _Q21 = float32(0.0015807170421) /* 0xcf3010.0p-33 */ + +func Xexpm1f(tls *TLS, x3 float32) (r float32) { + if __ccgo_strace { + trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var c, e, hfx, hi, hxs, lo, r1, t, twopk, y3 Tfloat_t + var hx Tuint32_t + var k, sign int32 + var y, v1 float32 + var y1, y2 float64 + var _ /* u at bp+0 */ struct { + Fi [0]Tuint32_t + Ff float32 + } + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, e, hfx, hi, hx, hxs, k, lo, r1, sign, t, twopk, y, y1, y2, y3, v1 + *(*struct { + Fi [0]Tuint32_t + Ff float32 + })(unsafe.Pointer(bp)) = struct { + Fi [0]Tuint32_t + Ff float32 + }{} + *(*float32)(unsafe.Pointer(bp)) = x3 + hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) + sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) + /* filter out huge and non-finite argument */ + if hx >= uint32(0x4195b844) { /* if |x|>=27*ln2 */ + if hx > uint32(0x7f800000) { /* NaN */ + return x3 + } + if sign != 0 { + return float32(-Int32FromInt32(1)) + } + if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ + x3 *= Float32FromFloat32(1.7014118346046923e+38) + return x3 + } + } + /* argument reduction */ + if hx > uint32(0x3eb17218) { /* if |x| > 0.5 ln2 */ + if hx < uint32(0x3F851592) { /* and |x| < 1.5 ln2 */ + if !(sign != 0) { + hi = x3 - _ln2_hi1 + lo = _ln2_lo1 + k = int32(1) + } else { + hi = x3 + _ln2_hi1 + lo = -_ln2_lo1 + k = -int32(1) + } + } else { + if sign != 0 { + v1 = -Float32FromFloat32(0.5) + } else { + v1 = Float32FromFloat32(0.5) + } + k = int32(float32(_invln21*x3) + v1) + t = float32(k) + 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 + } else { + if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ + if hx < uint32(0x00800000) { + if uint64(4) == uint64(4) { + y = float32(x3 * x3) + } else { + if uint64(4) == uint64(8) { + y1 = float64(x3 * x3) + } else { + y2 = float64(x3 * x3) + } + } + } + return x3 + } else { + k = 0 + } + } + /* x is now in primary range */ + 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 - (float32(x3*e) - hxs) + } + e = float32(x3*(e-c)) - c + e -= hxs + /* exp(x) ~ 2^k (Xreduced - e + 1) */ + if k == -int32(1) { + return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) + } + if k == int32(1) { + if x3 < -Float32FromFloat32(0.25) { + return float32(-Float32FromFloat32(2) * (e - (x3 + Float32FromFloat32(0.5)))) + } + 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 = Tfloat_t(Tfloat_t(y3*Float32FromFloat32(2)) * Float32FromFloat32(1.7014118346046923e+38)) + } else { + 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 = Tfloat_t((x3 - e + (Float32FromInt32(1) - *(*float32)(unsafe.Pointer(bp)))) * twopk) + } else { + y3 = Tfloat_t((x3 - (e + *(*float32)(unsafe.Pointer(bp))) + Float32FromInt32(1)) * twopk) + } + return y3 +} + +func Xexpm1l(tls *TLS, x float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x=%v, (%v:)", tls, x, origin(2)) + defer func() { trc("-> %v", r) }() + } + return Xexpm1(tls, x) +} + +type Tdouble_t = float64 +type Tuint32_t = uint32 +type Tuint64_t = uint64 + +var _o_threshold = float64(709.782712893384) /* 0x40862E42, 0xFEFA39EF */ +var _ln2_hi = float64(0.6931471803691238) /* 0x3fe62e42, 0xfee00000 */ +var _ln2_lo = float64(1.9082149292705877e-10) /* 0x3dea39ef, 0x35793c76 */ +var _invln2 = float64(1.4426950408889634) /* 0x3ff71547, 0x652b82fe */ +/* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = x*x/2: */ +var _Q1 = -Float64FromFloat64(0.03333333333333313) /* BFA11111 111110F4 */ +var _Q2 = float64(0.0015873015872548146) /* 3F5A01A0 19FE5585 */ +var _Q3 = -Float64FromFloat64(7.93650757867488e-05) /* BF14CE19 9EAADBB7 */ +var _Q4 = float64(4.008217827329362e-06) /* 3ED0CFCA 86E65239 */ +var _Q5 = -Float64FromFloat64(2.0109921818362437e-07) /* BE8AFDB7 6E09C32D */ + +var _ln2_hi2 = float64(0.6931471803691238) /* 3fe62e42 fee00000 */ +var _ln2_lo2 = float64(1.9082149292705877e-10) /* 3dea39ef 35793c76 */ +var _Lg12 = float64(0.6666666666666735) /* 3FE55555 55555593 */ +var _Lg22 = float64(0.3999999999940942) /* 3FD99999 9997FA04 */ +var _Lg32 = float64(0.2857142874366239) /* 3FD24924 94229359 */ +var _Lg42 = float64(0.22222198432149784) /* 3FCC71C5 1D8E78AF */ +var _Lg51 = float64(0.1818357216161805) /* 3FC74664 96CB03DE */ +var _Lg61 = float64(0.15313837699209373) /* 3FC39A09 D078C69F */ +var _Lg71 = float64(0.14798198605116586) /* 3FC2F112 DF3E5244 */ + +func Xlog1p(tls *TLS, x3 float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var R, c, dk, f, hfsq, s, t1, t2, w, z Tdouble_t + var hu, hx Tuint32_t + var k int32 + var y float32 + var y1, y2, v1 float64 + var _ /* u at bp+0 */ struct { + Fi [0]Tuint64_t + Ff float64 + } + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = R, c, dk, f, hfsq, hu, hx, k, s, t1, t2, w, y, y1, y2, z, v1 + *(*struct { + Fi [0]Tuint64_t + Ff float64 + })(unsafe.Pointer(bp)) = struct { + Fi [0]Tuint64_t + Ff float64 + }{} + *(*float64)(unsafe.Pointer(bp)) = x3 + hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) + k = int32(1) + if hx < uint32(0x3fda827a) || hx>>int32(31) != 0 { /* 1+x < sqrt(2)+ */ + if hx >= uint32(0xbff00000) { /* x <= -1.0 */ + if x3 == float64(-Int32FromInt32(1)) { + return x3 / float64(0) + } /* log1p(-1) = -inf */ + return (x3 - x3) / float64(0) /* log1p(x<-1) = NaN */ + } + if hx<<int32(1) < Uint32FromInt32(Int32FromInt32(0x3ca00000)<<Int32FromInt32(1)) { /* |x| < 2**-53 */ + /* underflow if subnormal */ + if hx&uint32(0x7ff00000) == uint32(0) { + if uint64(4) == uint64(4) { + y = float32(x3) + } else { + if uint64(4) == uint64(8) { + y1 = float64(float32(x3)) + } else { + y2 = float64(float32(x3)) + } + } + } + return x3 + } + if hx <= uint32(0xbfd2bec4) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */ + k = 0 + c = Float64FromInt32(0) + f = x3 + } + } else { + if hx >= uint32(0x7ff00000) { + return x3 + } + } + if k != 0 { + *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 + hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) + hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) + /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ + if k < int32(54) { + if k >= int32(2) { + v1 = Float64FromInt32(1) - (*(*float64)(unsafe.Pointer(bp)) - x3) + } else { + v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) + } + c = v1 + c /= *(*float64)(unsafe.Pointer(bp)) + } else { + c = Float64FromInt32(0) + } + /* reduce u into [sqrt(2)/2, sqrt(2)] */ + hu = hu&uint32(0x000fffff) + uint32(0x3fe6a09e) + *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hu)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff) + f = *(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1) + } + hfsq = Tdouble_t(float64(float64(0.5)*f) * f) + s = f / (Float64FromFloat64(2) + f) + 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 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 */ +var _ln2_lo3 = float32(9.0580006145e-06) /* 0x3717f7d1 */ +/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */ +var _Lg13 = float32(0.6666666269302368) /* 0.66666662693 */ +var _Lg23 = float32(0.40000972151756287) /* 0.40000972152 */ +var _Lg33 = float32(0.2849878668785095) /* 0.28498786688 */ +var _Lg43 = float32(0.24279078841209412) /* 0.24279078841 */ + +func Xlog1pf(tls *TLS, x3 float32) (r float32) { + if __ccgo_strace { + trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2)) + defer func() { trc("-> %v", r) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var R, c, dk, f, hfsq, s, t1, t2, w, z Tfloat_t + var iu, ix Tuint32_t + var k int32 + var y, v1 float32 + var y1, y2 float64 + var _ /* u at bp+0 */ struct { + Fi [0]Tuint32_t + Ff float32 + } + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = R, c, dk, f, hfsq, iu, ix, k, s, t1, t2, w, y, y1, y2, z, v1 + *(*struct { + Fi [0]Tuint32_t + Ff float32 + })(unsafe.Pointer(bp)) = struct { + Fi [0]Tuint32_t + Ff float32 + }{} + *(*float32)(unsafe.Pointer(bp)) = x3 + ix = *(*Tuint32_t)(unsafe.Pointer(bp)) + k = int32(1) + if ix < uint32(0x3ed413d0) || ix>>int32(31) != 0 { /* 1+x < sqrt(2)+ */ + if ix >= uint32(0xbf800000) { /* x <= -1.0 */ + if x3 == float32(-Int32FromInt32(1)) { + return x3 / Float32FromFloat32(0) + } /* log1p(-1)=+inf */ + return (x3 - x3) / Float32FromFloat32(0) /* log1p(x<-1)=NaN */ + } + if ix<<int32(1) < Uint32FromInt32(Int32FromInt32(0x33800000)<<Int32FromInt32(1)) { /* |x| < 2**-24 */ + /* underflow if subnormal */ + if ix&uint32(0x7f800000) == uint32(0) { + if uint64(4) == uint64(4) { + y = float32(x3 * x3) + } else { + if uint64(4) == uint64(8) { + y1 = float64(x3 * x3) + } else { + y2 = float64(x3 * x3) + } + } + } + return x3 + } + if ix <= uint32(0xbe95f619) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */ + k = 0 + c = Float32FromInt32(0) + f = x3 + } + } else { + if ix >= uint32(0x7f800000) { + return x3 + } + } + if k != 0 { + *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 + iu = *(*Tuint32_t)(unsafe.Pointer(bp)) + iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) + /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ + if k < int32(25) { + if k >= int32(2) { + v1 = Float32FromInt32(1) - (*(*float32)(unsafe.Pointer(bp)) - x3) + } else { + v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) + } + c = v1 + c /= *(*float32)(unsafe.Pointer(bp)) + } else { + c = Float32FromInt32(0) + } + /* reduce u into [sqrt(2)/2, sqrt(2)] */ + iu = iu&uint32(0x007fffff) + uint32(0x3f3504f3) + *(*Tuint32_t)(unsafe.Pointer(bp)) = iu + f = *(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1) + } + s = f / (Float32FromFloat32(2) + f) + 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 = Tfloat_t(float32(Float32FromFloat32(0.5)*f) * f) + dk = float32(k) + 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) { + if __ccgo_strace { + trc("tls=%v x=%v, (%v:)", tls, x, origin(2)) + defer func() { trc("-> %v", r) }() + } + return Xlog1p(tls, x) +} + +type Tfloat_t = float32 + +var _B1 = uint32(715094163) /* B1 = (1023-1023/3-0.03306235651)*2**20 */ +var _B2 = uint32(696219795) /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */ + +// C documentation +// +// /* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */ + +var _P0 = float64(1.87595182427177) /* 0x3ffe03e6, 0x0f61e692 */ +var _P1 = -Float64FromFloat64(1.8849797954337717) /* 0xbffe28e0, 0x92f02420 */ +var _P2 = float64(1.6214297201053545) /* 0x3ff9f160, 0x4a49d6c2 */ +var _P3 = -Float64FromFloat64(0.758397934778766) /* 0xbfe844cb, 0xbee751d9 */ +var _P4 = float64(0.14599619288661245) /* 0x3fc2b000, 0xd4e4edd7 */ + +func Xcbrt(tls *TLS, x float64) (r1 float64) { + if __ccgo_strace { + trc("tls=%v x=%v, (%v:)", tls, x, origin(2)) + defer func() { trc("-> %v", r1) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var hx Tuint32_t + var r, s, t, w Tdouble_t + var p1 uintptr + var _ /* u at bp+0 */ struct { + Fi [0]Tuint64_t + Ff float64 + } + _, _, _, _, _, _ = hx, r, s, t, w, p1 + *(*struct { + Fi [0]Tuint64_t + Ff float64 + })(unsafe.Pointer(bp)) = struct { + Fi [0]Tuint64_t + Ff float64 + }{} + *(*float64)(unsafe.Pointer(bp)) = x + hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) + if hx >= uint32(0x7ff00000) { /* cbrt(NaN,INF) is itself */ + return x + x + } + /* + * Rough cbrt to 5 bits: + * cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3) + * where e is integral and >= 0, m is real and in [0, 1), and "/" and + * "%" are integer division and modulus with rounding towards minus + * infinity. The RHS is always >= the LHS and has a maximum relative + * error of about 1 in 16. Adding a bias of -0.03306235651 to the + * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE + * floating point representation, for finite positive normal values, + * ordinary integer divison of the value in bits magically gives + * almost exactly the RHS of the above provided we first subtract the + * exponent bias (1023 for doubles) and later add it back. We do the + * subtraction virtually to keep e >= 0 so that ordinary integer + * division rounds towards minus infinity; this is also efficient. + */ + if hx < uint32(0x00100000) { /* zero or subnormal? */ + *(*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 + } /* cbrt(0) is itself */ + hx = hx/uint32(3) + _B2 + } else { + hx = hx/uint32(3) + _B1 + } + p1 = bp + *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) + t = *(*float64)(unsafe.Pointer(bp)) + /* + * New cbrt to 23 bits: + * cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x) + * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r) + * to within 2**-23.5 when |r - 1| < 1/10. The rough approximation + * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this + * gives us bounds for r = t**3/x. + * + * Try to optimize for parallel evaluation as in __tanf.c. + */ + 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 + * 2 23-bit ulps larger). With rounding towards zero, the error bound + * would be ~5/6 instead of ~4/6. With a maximum error of 2 23-bit ulps + * in the rounded t, the infinite-precision error in the Newton + * approximation barely affects third digit in the final error + * 0.667; the error in the rounded t can be up to about 3 23-bit ulps + * before the final error is larger than 0.667 ulps. + */ + *(*float64)(unsafe.Pointer(bp)) = t + *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000) + t = *(*float64)(unsafe.Pointer(bp)) + /* one step Newton iteration to 53 bits with error < 0.667 ulps */ + 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 +} + +var _B11 = uint32(709958130) /* B1 = (127-127.0/3-0.03306235651)*2**23 */ +var _B21 = uint32(642849266) /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */ + +func Xcbrtf(tls *TLS, x float32) (r1 float32) { + if __ccgo_strace { + trc("tls=%v x=%v, (%v:)", tls, x, origin(2)) + defer func() { trc("-> %v", r1) }() + } + bp := tls.Alloc(16) + defer tls.Free(16) + var T, r Tdouble_t + var hx Tuint32_t + var _ /* u at bp+0 */ struct { + Fi [0]Tuint32_t + Ff float32 + } + _, _, _ = T, hx, r + *(*struct { + Fi [0]Tuint32_t + Ff float32 + })(unsafe.Pointer(bp)) = struct { + Fi [0]Tuint32_t + Ff float32 + }{} + *(*float32)(unsafe.Pointer(bp)) = x + hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) + if hx >= uint32(0x7f800000) { /* cbrt(NaN,INF) is itself */ + return x + x + } + /* rough cbrt to 5 bits */ + if hx < uint32(0x00800000) { /* zero or subnormal? */ + if hx == uint32(0) { + return x + } /* cbrt(+-0) is itself */ + *(*float32)(unsafe.Pointer(bp)) = float32(x * Float32FromFloat32(1.6777216e+07)) + hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) + hx = hx/uint32(3) + _B21 + } else { + hx = hx/uint32(3) + _B11 + } + *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) + *(*Tuint32_t)(unsafe.Pointer(bp)) |= hx + /* + * First step Newton iteration (solving t*t-x/t == 0) to 16 bits. In + * double precision so that its terms can be arranged for efficiency + * without causing overflow or underflow. + */ + T = float64(*(*float32)(unsafe.Pointer(bp))) + 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 = 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) +} + +func Xcbrtl(tls *TLS, x float64) (r float64) { + if __ccgo_strace { + trc("tls=%v x=%v, (%v:)", tls, x, origin(2)) + defer func() { trc("-> %v", r) }() + } + return Xcbrt(tls, x) +} diff --git a/vendor/modernc.org/libc/libc_all.go b/vendor/modernc.org/libc/libc_all.go index 7bc730b76..001687e3c 100644 --- a/vendor/modernc.org/libc/libc_all.go +++ b/vendor/modernc.org/libc/libc_all.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// Package libc is a partial reimplementation of C libc in pure Go. package libc // import "modernc.org/libc" import ( diff --git a/vendor/modernc.org/libc/libc_darwin.go b/vendor/modernc.org/libc/libc_darwin.go index c33cc6ba2..bbad7d303 100644 --- a/vendor/modernc.org/libc/libc_darwin.go +++ b/vendor/modernc.org/libc/libc_darwin.go @@ -7,8 +7,11 @@ package libc // import "modernc.org/libc" import ( crand "crypto/rand" "encoding/hex" + "errors" "fmt" "io" + "io/fs" + mbits "math/bits" "os" "os/exec" gosignal "os/signal" @@ -39,6 +42,7 @@ import ( "modernc.org/libc/unistd" "modernc.org/libc/uuid/uuid" "modernc.org/libc/wctype" + "modernc.org/memory" ) const ( @@ -49,16 +53,14 @@ const ( // in6_addr_any in.In6_addr // ) +type Tsize_t = types.Size_t + type ( syscallErrno = unix.Errno long = types.User_long_t ulong = types.User_ulong_t ) -type pthreadAttr struct { - detachState int32 -} - // // Keep these outside of the var block otherwise go generate will miss them. var X__stderrp = Xstdout var X__stdinp = Xstdin @@ -94,6 +96,18 @@ func (f file) setErr() { (*stdio.FILE)(unsafe.Pointer(f)).F_flags |= 1 } +func (f file) clearErr() { + (*stdio.FILE)(unsafe.Pointer(f)).F_flags &^= 3 +} + +func (f file) eof() bool { + return (*stdio.FILE)(unsafe.Pointer(f)).F_flags&2 != 0 +} + +func (f file) setEOF() { + (*stdio.FILE)(unsafe.Pointer(f)).F_flags |= 2 +} + func (f file) close(t *TLS) int32 { r := Xclose(t, f.fd()) Xfree(t, uintptr(f)) @@ -125,6 +139,19 @@ func fwrite(fd int32, b []byte) (int, error) { return unix.Write(int(fd), b) } +func Xclearerr(tls *TLS, f uintptr) { + file(f).clearErr() +} + +func Xfeof(t *TLS, f uintptr) (r int32) { + if __ccgo_strace { + trc("t=%v f=%v, (%v:)", t, f, origin(2)) + defer func() { trc("-> %v", r) }() + } + r = BoolInt32(file(f).eof()) + return r +} + func X__inline_isnand(t *TLS, x float64) int32 { if __ccgo_strace { trc("t=%v x=%v, (%v:)", t, x, origin(2)) @@ -355,6 +382,9 @@ func Xlocaltime(_ *TLS, timep uintptr) uintptr { localtime.Ftm_wday = int32(t.Weekday()) localtime.Ftm_yday = int32(t.YearDay()) localtime.Ftm_isdst = Bool32(isTimeDST(t)) + _, off := t.Zone() + localtime.Ftm_gmtoff = int64(off) + localtime.Ftm_zone = 0 return uintptr(unsafe.Pointer(&localtime)) } @@ -372,6 +402,9 @@ func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr { (*time.Tm)(unsafe.Pointer(result)).Ftm_wday = int32(t.Weekday()) (*time.Tm)(unsafe.Pointer(result)).Ftm_yday = int32(t.YearDay()) (*time.Tm)(unsafe.Pointer(result)).Ftm_isdst = Bool32(isTimeDST(t)) + _, off := t.Zone() + (*time.Tm)(unsafe.Pointer(result)).Ftm_gmtoff = int64(off) + (*time.Tm)(unsafe.Pointer(result)).Ftm_zone = 0 return result } @@ -1539,6 +1572,9 @@ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types n, err = unix.Read(int(fd), nil) default: n, err = unix.Read(int(fd), (*RawMem)(unsafe.Pointer(ptr))[:count:count]) + if n == 0 { + file(stream).setEOF() + } if dmesgs && err == nil { dmesg("%v: fd %v, n %#x\n%s", origin(1), fd, n, hex.Dump((*RawMem)(unsafe.Pointer(ptr))[:n:n])) } @@ -1670,12 +1706,11 @@ func Xfputs(t *TLS, s, stream uintptr) int32 { if __ccgo_strace { trc("t=%v stream=%v, (%v:)", t, stream, origin(2)) } - panic(todo("")) - // if _, _, err := unix.Syscall(unix.SYS_WRITE, uintptr(file(stream).fd()), s, uintptr(Xstrlen(t, s))); err != 0 { - // return -1 - // } + if _, _, err := unix.Syscall(unix.SYS_WRITE, uintptr(file(stream).fd()), s, uintptr(Xstrlen(t, s))); err != 0 { + return -1 + } - // return 0 + return 0 } var getservbynameStaticResult netdb.Servent @@ -2174,11 +2209,13 @@ func Xpthread_attr_getdetachstate(tls *TLS, a uintptr, state uintptr) int32 { panic(todo("")) } -func Xpthread_attr_setdetachstate(tls *TLS, a uintptr, state int32) int32 { - if __ccgo_strace { - trc("tls=%v a=%v state=%v, (%v:)", tls, a, state, origin(2)) +func Xpthread_attr_setdetachstate(tls *TLS, a uintptr, state int32) (r int32) { + if uint32(state) > 1 { + return errno.EINVAL } - panic(todo("")) + + (*pthreadAttr)(unsafe.Pointer(a)).detachState = state + return 0 } func Xpthread_mutexattr_destroy(tls *TLS, a uintptr) int32 { @@ -2447,11 +2484,20 @@ func Xnanosleep(t *TLS, req, rem uintptr) int32 { // } // size_t malloc_size(const void *ptr); -func Xmalloc_size(t *TLS, ptr uintptr) types.Size_t { +func Xmalloc_size(t *TLS, p uintptr) (r types.Size_t) { if __ccgo_strace { - trc("t=%v ptr=%v, (%v:)", t, ptr, origin(2)) + trc("t=%v p=%v, (%v:)", t, p, origin(2)) + defer func() { trc("-> %v", r) }() } - panic(todo("")) + if p == 0 { + return 0 + } + + allocMu.Lock() + + defer allocMu.Unlock() + + return types.Size_t(memory.UintptrUsableSize(p)) } // int open(const char *pathname, int flags, ...); @@ -2518,3 +2564,226 @@ func X__builtin_lround(tls *TLS, x float64) (r long) { func Xlround(tls *TLS, x float64) (r long) { return long(Xround(tls, x)) } + +// https://g.co/gemini/share/2c37d5b57994 + +// Constants mirroring C's ftw type flags +const ( + FTW_F = 0 // Regular file + FTW_D = 1 // Directory (visited pre-order) + FTW_DNR = 2 // Directory that cannot be read + FTW_NS = 4 // Stat failed (permissions, broken link, etc.) + FTW_SL = 4 // Symbolic link (lstat was used) + // Note: C's ftw might have other flags like FTW_DP (post-order dir) or FTW_SLN + // which are not directly supported by filepath.WalkDir's simple pre-order traversal. + // This emulation focuses on the most common flags associated with stat/lstat results. +) + +// ftwStopError is used internally to signal that the walk should stop +// because the user callback returned a non-zero value. +type ftwStopError struct { + stopValue int +} + +func (e *ftwStopError) Error() string { + return fmt.Sprintf("ftw walk stopped by callback with return value %d", e.stopValue) +} + +// goFtwFunc is the callback function type, mirroring the C ftw callback. +// It receives the path, file info (if available), and a type flag. +// Returning a non-zero value stops the walk and becomes the return value of Ftw. +// Returning 0 continues the walk. +type goFtwFunc func(path string, info os.FileInfo, typeflag int) int + +// Ftw emulates the C standard library function ftw(3). +// It walks the directory tree starting at 'dirpath' and calls the 'callback' +// function for each entry encountered. +// +// Parameters: +// - dirpath: The root directory path for the traversal. +// - callback: The goFtwFunc to call for each file system entry. +// - nopenfd: This parameter is part of the C ftw signature but is IGNORED +// in this Go implementation. Go's filepath.WalkDir manages concurrency +// and file descriptors internally. +// +// Returns: +// - 0 on successful completion of the walk. +// - The non-zero value returned by the callback, if the callback terminated the walk. +// - -1 if an error occurred during the walk that wasn't handled by calling +// the callback with FTW_DNR or FTW_NS (e.g., error accessing the initial dirpath). +func ftw(dirpath string, callback goFtwFunc, nopenfd int) int { + // nopenfd is ignored in this Go implementation. + + walkErr := filepath.WalkDir(dirpath, func(path string, d fs.DirEntry, err error) error { + var info os.FileInfo + var typeflag int + + // --- Handle errors passed by WalkDir --- + if err != nil { + // Check if the error is related to accessing a directory + if errors.Is(err, fs.ErrPermission) || errors.Is(err, unix.EACCES) { // Added syscall.EACCES check + // Try to determine if it's a directory we can't read + // We might not have 'd' if the error occurred trying to list 'path' contents + // Let's try a direct Lstat on the path itself if d is nil + lstatInfo, lstatErr := os.Lstat(path) + if lstatErr == nil && lstatInfo.IsDir() { + typeflag = FTW_DNR // Directory, but WalkDir errored (likely reading it) + info = lstatInfo // Provide the info we could get + } else { + // Can't confirm it's a directory, or Lstat itself failed + typeflag = FTW_NS // Treat as general stat failure + // info remains nil + } + } else { + // Other errors (e.g., broken symlink during traversal, I/O error) + typeflag = FTW_NS + // Attempt to get Lstat info even if WalkDir had an error, maybe it's available + lstatInfo, _ := os.Lstat(path) // Ignore error here, if it fails info stays nil + info = lstatInfo + } + // Even with errors, call the callback with the path and appropriate flag + stopVal := callback(path, info, typeflag) + if stopVal != 0 { + return &ftwStopError{stopValue: stopVal} + } + // If the error was on a directory, returning the error might stop WalkDir + // from descending. If it was fs.ErrPermission on a dir, WalkDir might + // pass filepath.SkipDir implicitly or continue depending on implementation. + // Let's return nil here to *try* to continue the walk for other siblings + // if the callback didn't stop it. The callback *was* notified. + // If the error prevents further progress WalkDir will stop anyway. + return nil // Allow walk to potentially continue elsewhere + } + + // --- No error from WalkDir, process the DirEntry --- + info, err = d.Info() // Get FileInfo (like C's stat/lstat result) + if err != nil { + // Error getting info for an entry WalkDir *could* list (rare, maybe permissions changed?) + typeflag = FTW_NS + // info remains nil + } else { + // Determine type flag based on file mode + mode := info.Mode() + if mode&fs.ModeSymlink != 0 { + typeflag = FTW_SL + } else if mode.IsDir() { + typeflag = FTW_D // Visited pre-order + } else if mode.IsRegular() { + typeflag = FTW_F + } else { + // Other types (device, socket, pipe, etc.) - C ftw usually lumps these under FTW_F + // or might have FTW_NS if stat fails. Let's treat non-dir, non-link, non-regular + // as FTW_F for simplicity, aligning with common C practice, or FTW_NS if stat failed above. + // Since we have info here, we know stat didn't fail. + // Let's be more specific, maybe treat others as FTW_NS? Or stick to FTW_F? + // C ftw man page isn't super specific about all types. FTW_F seems reasonable. + typeflag = FTW_F // Treat other valid types as 'files' for simplicity + } + } + + // --- Call the user callback --- + stopVal := callback(path, info, typeflag) + if stopVal != 0 { + // User wants to stop the walk + return &ftwStopError{stopValue: stopVal} + } + + return nil // Continue walk + }) + + // --- Handle WalkDir's final return value --- + if walkErr == nil { + return 0 // Success + } + + // Check if the error was our custom stop signal + var stopErr *ftwStopError + if errors.As(walkErr, &stopErr) { + return stopErr.stopValue // Return the value from the callback + } + + // Otherwise, it was an unhandled error during the walk + // (e.g., initial dirpath access error, or other error not mapped to FTW_NS/DNR) + return -1 // General error return +} + +func Xftw(tls *TLS, path uintptr, fn uintptr, fd_limit int32) (r int32) { + statp := tls.Alloc(int(unsafe.Sizeof(unix.Stat_t{}))) + + defer tls.Free(int(unsafe.Sizeof(unix.Stat_t{}))) + + return int32(ftw( + GoString(path), + func(path string, info os.FileInfo, typeflag int) int { + cs, _ := CString(path) + + defer Xfree(tls, cs) + + Xstat(tls, cs, statp) + return int((*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{fn})))(tls, cs, statp, int32(typeflag))) + }, + int(fd_limit), + )) +} + +func Xexecve(tls *TLS, path uintptr, argv uintptr, envp uintptr) (r int32) { + goPath := GoString(path) + var goArgv, goEnvp []string + for p := *(*uintptr)(unsafe.Pointer(argv)); p != 0; p = *(*uintptr)(unsafe.Pointer(argv)) { + goArgv = append(goArgv, GoString(p)) + argv += unsafe.Sizeof(uintptr(0)) + } + for p := *(*uintptr)(unsafe.Pointer(envp)); p != 0; p = *(*uintptr)(unsafe.Pointer(envp)) { + goEnvp = append(goEnvp, GoString(p)) + envp += unsafe.Sizeof(uintptr(0)) + } + if err := unix.Exec(goPath, goArgv, goEnvp); err != nil { + tls.setErrno(err) + return -1 + } + panic("unreachable") +} + +func Xsetuid(tls *TLS, uid uint32) (r int32) { + if __ccgo_strace { + trc("tls=%v uid=%v, (%v:)", tls, uid, origin(2)) + defer func() { trc("-> %v", r) }() + } + if err := unix.Setuid(int(uid)); err != nil { + tls.setErrno(err) + return -1 + } + + return 0 +} + +func Xsetgid(tls *TLS, gid uint32) (r int32) { + if __ccgo_strace { + trc("tls=%v gid=%v, (%v:)", tls, gid, origin(2)) + defer func() { trc("-> %v", r) }() + } + if err := unix.Setgid(int(gid)); err != nil { + tls.setErrno(err) + return -1 + } + + return 0 +} + +func Xdup(tls *TLS, fd int32) (r int32) { + if __ccgo_strace { + trc("tls=%v fd=%v, (%v:)", tls, fd, origin(2)) + defer func() { trc("-> %v", r) }() + } + nfd, err := unix.Dup(int(fd)) + if err != nil { + tls.setErrno(err) + return -1 + } + + return int32(nfd) +} + +func X__builtin_ctz(t *TLS, n uint32) int32 { + return int32(mbits.TrailingZeros32(n)) +} diff --git a/vendor/modernc.org/libc/libc_darwin_amd64.go b/vendor/modernc.org/libc/libc_darwin_amd64.go index 0513b1e49..dd94ebab3 100644 --- a/vendor/modernc.org/libc/libc_darwin_amd64.go +++ b/vendor/modernc.org/libc/libc_darwin_amd64.go @@ -17,6 +17,11 @@ import ( "modernc.org/libc/utime" ) +// #define FE_DOWNWARD 0x0400 +// #define FE_UPWARD 0x0800 +const FE_DOWNWARD = 0x0400 +const FE_UPWARD = 0x0800 + // int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); func Xsigaction(t *TLS, signum int32, act, oldact uintptr) int32 { if __ccgo_strace { diff --git a/vendor/modernc.org/libc/libc_darwin_arm64.go b/vendor/modernc.org/libc/libc_darwin_arm64.go index ecb7c911d..9e85e8911 100644 --- a/vendor/modernc.org/libc/libc_darwin_arm64.go +++ b/vendor/modernc.org/libc/libc_darwin_arm64.go @@ -17,6 +17,11 @@ import ( "modernc.org/libc/utime" ) +// #define FE_UPWARD 0x00400000 +// #define FE_DOWNWARD 0x00800000 +const FE_UPWARD = 0x00400000 +const FE_DOWNWARD = 0x00800000 + // int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); func Xsigaction(t *TLS, signum int32, act, oldact uintptr) int32 { if __ccgo_strace { diff --git a/vendor/modernc.org/libc/libc_freebsd.go b/vendor/modernc.org/libc/libc_freebsd.go index 4fcae6780..0da77b0ab 100644 --- a/vendor/modernc.org/libc/libc_freebsd.go +++ b/vendor/modernc.org/libc/libc_freebsd.go @@ -5,8 +5,12 @@ package libc // import "modernc.org/libc" import ( + "errors" "fmt" "io" + "io/fs" + "math" + mbits "math/bits" "os" "os/exec" "path/filepath" @@ -65,6 +69,8 @@ func X__runes_for_locale(t *TLS, l locale_t, p uintptr) uintptr { panic(todo("")) } +type Tsize_t = types.Size_t + type syscallErrno = unix.Errno type file uintptr @@ -80,6 +86,18 @@ func (f file) setErr() { (*stdio.FILE)(unsafe.Pointer(f)).F_flags |= 1 } +func (f file) clearErr() { + (*stdio.FILE)(unsafe.Pointer(f)).F_flags &^= 3 +} + +func (f file) eof() bool { + return (*stdio.FILE)(unsafe.Pointer(f)).F_flags&2 != 0 +} + +func (f file) setEOF() { + (*stdio.FILE)(unsafe.Pointer(f)).F_flags |= 2 +} + func (f file) close(t *TLS) int32 { r := Xclose(t, f.fd()) Xfree(t, uintptr(f)) @@ -110,6 +128,19 @@ func fwrite(fd int32, b []byte) (int, error) { return unix.Write(int(fd), b) //TODO use Xwrite } +func Xclearerr(tls *TLS, f uintptr) { + file(f).clearErr() +} + +func Xfeof(t *TLS, f uintptr) (r int32) { + if __ccgo_strace { + trc("t=%v f=%v, (%v:)", t, f, origin(2)) + defer func() { trc("-> %v", r) }() + } + r = BoolInt32(file(f).eof()) + return r +} + // unsigned long ___runetype(__ct_rune_t) __pure; func X___runetype(t *TLS, x types.X__ct_rune_t) ulong { if __ccgo_strace { @@ -199,6 +230,7 @@ var localtime time.Tm // struct tm *localtime(const time_t *timep); func Xlocaltime(_ *TLS, timep uintptr) uintptr { + // trc("%T timep=%+v", time.Time_t(0), *(*time.Time_t)(unsafe.Pointer(timep))) loc := getLocalLocation() ut := *(*time.Time_t)(unsafe.Pointer(timep)) t := gotime.Unix(int64(ut), 0).In(loc) @@ -211,11 +243,16 @@ func Xlocaltime(_ *TLS, timep uintptr) uintptr { localtime.Ftm_wday = int32(t.Weekday()) localtime.Ftm_yday = int32(t.YearDay()) localtime.Ftm_isdst = Bool32(isTimeDST(t)) + _, off := t.Zone() + localtime.Ftm_gmtoff = int64(off) + localtime.Ftm_zone = 0 + // trc("%T localtime=%+v", localtime, localtime) return uintptr(unsafe.Pointer(&localtime)) } // struct tm *localtime_r(const time_t *timep, struct tm *result); func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr { + // trc("%T timep=%+v", time.Time_t(0), *(*time.Time_t)(unsafe.Pointer(timep))) loc := getLocalLocation() ut := *(*unix.Time_t)(unsafe.Pointer(timep)) t := gotime.Unix(int64(ut), 0).In(loc) @@ -228,6 +265,10 @@ func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr { (*time.Tm)(unsafe.Pointer(result)).Ftm_wday = int32(t.Weekday()) (*time.Tm)(unsafe.Pointer(result)).Ftm_yday = int32(t.YearDay()) (*time.Tm)(unsafe.Pointer(result)).Ftm_isdst = Bool32(isTimeDST(t)) + _, off := t.Zone() + (*time.Tm)(unsafe.Pointer(result)).Ftm_gmtoff = int64(off) + (*time.Tm)(unsafe.Pointer(result)).Ftm_zone = 0 + // trc("%T localtime_r=%+v", localtime, (*time.Tm)(unsafe.Pointer(result))) return result } @@ -501,6 +542,7 @@ func Xgettimeofday(t *TLS, tv, tz uintptr) int32 { return -1 } + //trc("tvs=%+v", tvs) *(*unix.Timeval)(unsafe.Pointer(tv)) = tvs return 0 } @@ -1563,12 +1605,167 @@ func fcntlCmdStr(cmd int32) string { } } +func X__strchrnul(tls *TLS, s uintptr, c int32) uintptr { /* strchrnul.c:10:6: */ + if __ccgo_strace { + trc("tls=%v s=%v c=%v, (%v:)", tls, s, c, origin(2)) + } + c = int32(uint8(c)) + if !(c != 0) { + return s + uintptr(Xstrlen(tls, s)) + } + var w uintptr + for ; uintptr_t(s)%uintptr_t(unsafe.Sizeof(size_t(0))) != 0; s++ { + if !(int32(*(*int8)(unsafe.Pointer(s))) != 0) || int32(*(*uint8)(unsafe.Pointer(s))) == c { + return s + } + } + var k size_t = Uint64(Uint64FromInt32(-1)) / uint64(255) * size_t(c) + for w = s; !((*(*uint64)(unsafe.Pointer(w))-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0); w += 8 { + } + s = w + for ; *(*int8)(unsafe.Pointer(s)) != 0 && int32(*(*uint8)(unsafe.Pointer(s))) != c; s++ { + } + return s +} + +var _soldenv uintptr /* putenv.c:22:14: */ + // int setenv(const char *name, const char *value, int overwrite); -func Xsetenv(t *TLS, name, value uintptr, overwrite int32) int32 { +func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) int32 { /* setenv.c:26:5: */ if __ccgo_strace { - trc("t=%v value=%v overwrite=%v, (%v:)", t, value, overwrite, origin(2)) + trc("tls=%v var1=%v value=%v overwrite=%v, (%v:)", tls, var1, value, overwrite, origin(2)) } - panic(todo("")) + var s uintptr + var l1 size_t + var l2 size_t + + if !(var1 != 0) || !(int32(AssignUint64(&l1, size_t((int64(X__strchrnul(tls, var1, '='))-int64(var1))/1))) != 0) || *(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { + *(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22 + return -1 + } + if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { + return 0 + } + + l2 = Xstrlen(tls, value) + s = Xmalloc(tls, l1+l2+uint64(2)) + if !(s != 0) { + return -1 + } + Xmemcpy(tls, s, var1, l1) + *(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=') + Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) + return X__putenv(tls, s, l1, s) +} + +func X__putenv(tls *TLS, s uintptr, l size_t, r uintptr) int32 { /* putenv.c:8:5: */ + if __ccgo_strace { + trc("tls=%v s=%v l=%v r=%v, (%v:)", tls, s, l, r, origin(2)) + } + var i size_t + var newenv uintptr + var tmp uintptr + //TODO for (char **e = __environ; *e; e++, i++) + var e uintptr + i = uint64(0) + if !(Environ() != 0) { + goto __1 + } + //TODO for (char **e = __environ; *e; e++, i++) + e = Environ() +__2: + if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + goto __4 + } + if !!(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { + goto __5 + } + tmp = *(*uintptr)(unsafe.Pointer(e)) + *(*uintptr)(unsafe.Pointer(e)) = s + X__env_rm_add(tls, tmp, r) + return 0 +__5: + ; + goto __3 +__3: + e += 8 + i++ + goto __2 + goto __4 +__4: + ; +__1: + ; + if !(Environ() == _soldenv) { + goto __6 + } + newenv = Xrealloc(tls, _soldenv, uint64(unsafe.Sizeof(uintptr(0)))*(i+uint64(2))) + if !!(newenv != 0) { + goto __8 + } + goto oom +__8: + ; + goto __7 +__6: + newenv = Xmalloc(tls, uint64(unsafe.Sizeof(uintptr(0)))*(i+uint64(2))) + if !!(newenv != 0) { + goto __9 + } + goto oom +__9: + ; + if !(i != 0) { + goto __10 + } + Xmemcpy(tls, newenv, Environ(), uint64(unsafe.Sizeof(uintptr(0)))*i) +__10: + ; + Xfree(tls, _soldenv) +__7: + ; + *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s + *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + *(*uintptr)(unsafe.Pointer(EnvironP())) = AssignPtrUintptr(uintptr(unsafe.Pointer(&_soldenv)), newenv) + if !(r != 0) { + goto __11 + } + X__env_rm_add(tls, uintptr(0), r) +__11: + ; + return 0 +oom: + Xfree(tls, r) + return -1 +} + +var _senv_alloced uintptr /* setenv.c:7:14: */ +var _senv_alloced_n size_t /* setenv.c:8:16: */ + +func X__env_rm_add(tls *TLS, old uintptr, new uintptr) { /* setenv.c:5:6: */ + if __ccgo_strace { + trc("tls=%v old=%v new=%v, (%v:)", tls, old, new, origin(2)) + } + //TODO for (size_t i=0; i < env_alloced_n; i++) + var i size_t = uint64(0) + for ; i < _senv_alloced_n; i++ { + if *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) == old { + *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) = new + Xfree(tls, old) + return + } else if !(int32(*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8))) != 0) && new != 0 { + *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) = new + new = uintptr(0) + } + } + if !(new != 0) { + return + } + var t uintptr = Xrealloc(tls, _senv_alloced, uint64(unsafe.Sizeof(uintptr(0)))*(_senv_alloced_n+uint64(1))) + if !(t != 0) { + return + } + *(*uintptr)(unsafe.Pointer(AssignPtrUintptr(uintptr(unsafe.Pointer(&_senv_alloced)), t) + uintptr(PostIncUint64(&_senv_alloced_n, 1))*8)) = new } // int unsetenv(const char *name); @@ -2036,3 +2233,238 @@ __3: ; return Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(r)))) } + +func X__isfinite(tls *TLS, d float64) int32 { + if !math.IsInf(d, 0) && !math.IsNaN(d) { + return 1 + } + + return 0 +} + +func X__signbit(tls *TLS, x float64) (r int32) { + return int32(math.Float64bits(x) >> 63) +} + +func X__builtin_ctz(t *TLS, n uint32) int32 { + return int32(mbits.TrailingZeros32(n)) +} + +// https://g.co/gemini/share/2c37d5b57994 + +// Constants mirroring C's ftw type flags +const ( + FTW_F = 0 // Regular file + FTW_D = 1 // Directory (visited pre-order) + FTW_DNR = 2 // Directory that cannot be read + FTW_NS = 4 // Stat failed (permissions, broken link, etc.) + FTW_SL = 4 // Symbolic link (lstat was used) + // Note: C's ftw might have other flags like FTW_DP (post-order dir) or FTW_SLN + // which are not directly supported by filepath.WalkDir's simple pre-order traversal. + // This emulation focuses on the most common flags associated with stat/lstat results. +) + +// ftwStopError is used internally to signal that the walk should stop +// because the user callback returned a non-zero value. +type ftwStopError struct { + stopValue int +} + +func (e *ftwStopError) Error() string { + return fmt.Sprintf("ftw walk stopped by callback with return value %d", e.stopValue) +} + +// goFtwFunc is the callback function type, mirroring the C ftw callback. +// It receives the path, file info (if available), and a type flag. +// Returning a non-zero value stops the walk and becomes the return value of Ftw. +// Returning 0 continues the walk. +type goFtwFunc func(path string, info os.FileInfo, typeflag int) int + +// Ftw emulates the C standard library function ftw(3). +// It walks the directory tree starting at 'dirpath' and calls the 'callback' +// function for each entry encountered. +// +// Parameters: +// - dirpath: The root directory path for the traversal. +// - callback: The goFtwFunc to call for each file system entry. +// - nopenfd: This parameter is part of the C ftw signature but is IGNORED +// in this Go implementation. Go's filepath.WalkDir manages concurrency +// and file descriptors internally. +// +// Returns: +// - 0 on successful completion of the walk. +// - The non-zero value returned by the callback, if the callback terminated the walk. +// - -1 if an error occurred during the walk that wasn't handled by calling +// the callback with FTW_DNR or FTW_NS (e.g., error accessing the initial dirpath). +func ftw(dirpath string, callback goFtwFunc, nopenfd int) int { + // nopenfd is ignored in this Go implementation. + + walkErr := filepath.WalkDir(dirpath, func(path string, d fs.DirEntry, err error) error { + var info os.FileInfo + var typeflag int + + // --- Handle errors passed by WalkDir --- + if err != nil { + // Check if the error is related to accessing a directory + if errors.Is(err, fs.ErrPermission) || errors.Is(err, unix.EACCES) { // Added syscall.EACCES check + // Try to determine if it's a directory we can't read + // We might not have 'd' if the error occurred trying to list 'path' contents + // Let's try a direct Lstat on the path itself if d is nil + lstatInfo, lstatErr := os.Lstat(path) + if lstatErr == nil && lstatInfo.IsDir() { + typeflag = FTW_DNR // Directory, but WalkDir errored (likely reading it) + info = lstatInfo // Provide the info we could get + } else { + // Can't confirm it's a directory, or Lstat itself failed + typeflag = FTW_NS // Treat as general stat failure + // info remains nil + } + } else { + // Other errors (e.g., broken symlink during traversal, I/O error) + typeflag = FTW_NS + // Attempt to get Lstat info even if WalkDir had an error, maybe it's available + lstatInfo, _ := os.Lstat(path) // Ignore error here, if it fails info stays nil + info = lstatInfo + } + // Even with errors, call the callback with the path and appropriate flag + stopVal := callback(path, info, typeflag) + if stopVal != 0 { + return &ftwStopError{stopValue: stopVal} + } + // If the error was on a directory, returning the error might stop WalkDir + // from descending. If it was fs.ErrPermission on a dir, WalkDir might + // pass filepath.SkipDir implicitly or continue depending on implementation. + // Let's return nil here to *try* to continue the walk for other siblings + // if the callback didn't stop it. The callback *was* notified. + // If the error prevents further progress WalkDir will stop anyway. + return nil // Allow walk to potentially continue elsewhere + } + + // --- No error from WalkDir, process the DirEntry --- + info, err = d.Info() // Get FileInfo (like C's stat/lstat result) + if err != nil { + // Error getting info for an entry WalkDir *could* list (rare, maybe permissions changed?) + typeflag = FTW_NS + // info remains nil + } else { + // Determine type flag based on file mode + mode := info.Mode() + if mode&fs.ModeSymlink != 0 { + typeflag = FTW_SL + } else if mode.IsDir() { + typeflag = FTW_D // Visited pre-order + } else if mode.IsRegular() { + typeflag = FTW_F + } else { + // Other types (device, socket, pipe, etc.) - C ftw usually lumps these under FTW_F + // or might have FTW_NS if stat fails. Let's treat non-dir, non-link, non-regular + // as FTW_F for simplicity, aligning with common C practice, or FTW_NS if stat failed above. + // Since we have info here, we know stat didn't fail. + // Let's be more specific, maybe treat others as FTW_NS? Or stick to FTW_F? + // C ftw man page isn't super specific about all types. FTW_F seems reasonable. + typeflag = FTW_F // Treat other valid types as 'files' for simplicity + } + } + + // --- Call the user callback --- + stopVal := callback(path, info, typeflag) + if stopVal != 0 { + // User wants to stop the walk + return &ftwStopError{stopValue: stopVal} + } + + return nil // Continue walk + }) + + // --- Handle WalkDir's final return value --- + if walkErr == nil { + return 0 // Success + } + + // Check if the error was our custom stop signal + var stopErr *ftwStopError + if errors.As(walkErr, &stopErr) { + return stopErr.stopValue // Return the value from the callback + } + + // Otherwise, it was an unhandled error during the walk + // (e.g., initial dirpath access error, or other error not mapped to FTW_NS/DNR) + return -1 // General error return +} + +func Xftw(tls *TLS, path uintptr, fn uintptr, fd_limit int32) (r int32) { + statp := tls.Alloc(int(unsafe.Sizeof(unix.Stat_t{}))) + + defer tls.Free(int(unsafe.Sizeof(unix.Stat_t{}))) + + return int32(ftw( + GoString(path), + func(path string, info os.FileInfo, typeflag int) int { + cs, _ := CString(path) + + defer Xfree(tls, cs) + + Xstat(tls, cs, statp) + return int((*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{fn})))(tls, cs, statp, int32(typeflag))) + }, + int(fd_limit), + )) +} + +func Xexecve(tls *TLS, path uintptr, argv uintptr, envp uintptr) (r int32) { + goPath := GoString(path) + var goArgv, goEnvp []string + for p := *(*uintptr)(unsafe.Pointer(argv)); p != 0; p = *(*uintptr)(unsafe.Pointer(argv)) { + goArgv = append(goArgv, GoString(p)) + argv += unsafe.Sizeof(uintptr(0)) + } + for p := *(*uintptr)(unsafe.Pointer(envp)); p != 0; p = *(*uintptr)(unsafe.Pointer(envp)) { + goEnvp = append(goEnvp, GoString(p)) + envp += unsafe.Sizeof(uintptr(0)) + } + if err := unix.Exec(goPath, goArgv, goEnvp); err != nil { + tls.setErrno(err) + return -1 + } + panic("unreachable") +} + +func Xsetuid(tls *TLS, uid uint32) (r int32) { + if __ccgo_strace { + trc("tls=%v uid=%v, (%v:)", tls, uid, origin(2)) + defer func() { trc("-> %v", r) }() + } + if err := unix.Setuid(int(uid)); err != nil { + tls.setErrno(err) + return -1 + } + + return 0 +} + +func Xsetgid(tls *TLS, gid uint32) (r int32) { + if __ccgo_strace { + trc("tls=%v gid=%v, (%v:)", tls, gid, origin(2)) + defer func() { trc("-> %v", r) }() + } + if err := unix.Setgid(int(gid)); err != nil { + tls.setErrno(err) + return -1 + } + + return 0 +} + +func Xdup(tls *TLS, fd int32) (r int32) { + if __ccgo_strace { + trc("tls=%v fd=%v, (%v:)", tls, fd, origin(2)) + defer func() { trc("-> %v", r) }() + } + nfd, err := unix.Dup(int(fd)) + if err != nil { + tls.setErrno(err) + return -1 + } + + return int32(nfd) +} diff --git a/vendor/modernc.org/libc/libc_illumos.go b/vendor/modernc.org/libc/libc_illumos.go index 390012810..79f80c9b5 100644 --- a/vendor/modernc.org/libc/libc_illumos.go +++ b/vendor/modernc.org/libc/libc_illumos.go @@ -2094,3 +2094,11 @@ func (s *byteScanner) UnreadByte() error { Xungetc(s.t, int32(s.last), s.stream) return nil } + +// int clock_gettime(clockid_t clk_id, struct timespec *tp); +func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32 { + if __ccgo_strace { + trc("t=%v clk_id=%v tp=%v, (%v:)", t, clk_id, tp, origin(2)) + } + panic(todo("")) +} diff --git a/vendor/modernc.org/libc/libc_musl.go b/vendor/modernc.org/libc/libc_musl.go index e2d5220a0..fc58b07a2 100644 --- a/vendor/modernc.org/libc/libc_musl.go +++ b/vendor/modernc.org/libc/libc_musl.go @@ -15,7 +15,7 @@ // have generated some Go code from C you should stick to the version of this // package that you used at that time and was tested with your payload. The // correct way to upgrade to a newer version of this package is to first -// recompile (C to Go) your code with a newwer version if ccgo that depends on +// recompile (C to Go) your code with a newer version of ccgo that depends on // the new libc version. // // If you use C to Go translated code provided by others, stick to the version @@ -296,6 +296,11 @@ func NewTLS() (r *TLS) { } } +// StackSlots reports the number of tls stack slots currently in use. +func (tls *TLS) StackSlots() int { + return tls.sp +} + // int *__errno_location(void) func X__errno_location(tls *TLS) (r uintptr) { return tls.pthread + unsafe.Offsetof(t__pthread{}.Ferrno_val) diff --git a/vendor/modernc.org/libc/libc_netbsd.go b/vendor/modernc.org/libc/libc_netbsd.go index 2b9f4501d..3bf0a2b65 100644 --- a/vendor/modernc.org/libc/libc_netbsd.go +++ b/vendor/modernc.org/libc/libc_netbsd.go @@ -86,6 +86,8 @@ func X__runes_for_locale(t *TLS, l locale_t, p uintptr) uintptr { panic(todo("")) } +type Tsize_t = types.Size_t + type file uintptr func (f file) fd() int32 { return int32((*stdio.FILE)(unsafe.Pointer(f)).F_file) } diff --git a/vendor/modernc.org/libc/libc_openbsd.go b/vendor/modernc.org/libc/libc_openbsd.go index 16c4afd58..09e7a563c 100644 --- a/vendor/modernc.org/libc/libc_openbsd.go +++ b/vendor/modernc.org/libc/libc_openbsd.go @@ -43,6 +43,8 @@ var ( in6_addr_any in.In6_addr ) +type Tsize_t = types.Size_t + type syscallErrno = unix.Errno // // Keep these outside of the var block otherwise go generate will miss them. diff --git a/vendor/modernc.org/libc/libc_unix.go b/vendor/modernc.org/libc/libc_unix.go index 1d9f1b12b..5328252f8 100644 --- a/vendor/modernc.org/libc/libc_unix.go +++ b/vendor/modernc.org/libc/libc_unix.go @@ -1386,3 +1386,19 @@ func x___secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { (*ctime.Tm)(unsafe.Pointer(tm)).Ftm_sec = remsecs % int32(60) return 0 } + +// int clock_gettime(clockid_t clk_id, struct timespec *tp); +func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32 { + if __ccgo_strace { + trc("t=%v clk_id=%v tp=%v, (%v:)", t, clk_id, tp, origin(2)) + } + var ts unix.Timespec + if err := unix.ClockGettime(clk_id, &ts); err != nil { + t.setErrno(err) + trc("FAIL: %v", err) + return -1 + } + + *(*unix.Timespec)(unsafe.Pointer(tp)) = ts + return 0 +} diff --git a/vendor/modernc.org/libc/libc_windows.go b/vendor/modernc.org/libc/libc_windows.go index 79bd88fc1..3409f3331 100644 --- a/vendor/modernc.org/libc/libc_windows.go +++ b/vendor/modernc.org/libc/libc_windows.go @@ -9,6 +9,7 @@ import ( "fmt" "golang.org/x/sys/windows" "math" + mbits "math/bits" "os" "os/exec" "os/user" @@ -42,6 +43,8 @@ var X_iob [stdio.X_IOB_ENTRIES]stdio.FILE var Xin6addr_any [16]byte var Xtimezone long // extern long timezone; +type Tsize_t = types.Size_t + var ( iobMap = map[uintptr]int32{} // &_iob[fd] -> fd wenvValid bool @@ -845,25 +848,49 @@ func Xmunmap(t *TLS, addr uintptr, length types.Size_t) int32 { // return 0 } +type Timeval = struct { + Ftv_sec int32 + Ftv_usec int32 +} + // int gettimeofday(struct timeval *tv, struct timezone *tz); func Xgettimeofday(t *TLS, tv, tz uintptr) int32 { if __ccgo_strace { trc("t=%v tz=%v, (%v:)", t, tz, origin(2)) } - panic(todo("")) - // if tz != 0 { - // panic(todo("")) - // } - - // var tvs unix.Timeval - // err := unix.Gettimeofday(&tvs) - // if err != nil { - // t.setErrno(err) - // return -1 - // } + if tv == 0 { + return 0 + } - // *(*unix.Timeval)(unsafe.Pointer(tv)) = tvs + // This seems to work as well + // var u64 uint64 + // procGetSystemTimeAsFileTime.Call(uintptr(unsafe.Pointer(&u64)), 0, 0) + // u64 /= 10 + // u64 -= 11644473600000000 + // (*Timeval)(unsafe.Pointer(tv)).Ftv_sec = int32(u64/1e6) + // (*Timeval)(unsafe.Pointer(tv)).Ftv_usec = int32(u64%1e6) // return 0 + + // But let's use the golang.org/x/sys version + windows.Gettimeofday((*windows.Timeval)(unsafe.Pointer(tv))) + return 0 +} + +type Timespec = struct { + Ftv_sec time.Time_t + Ftv_nsec int32 +} + +// int clock_gettime(clockid_t clk_id, struct timespec *tp); +func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32 { + if __ccgo_strace { + trc("t=%v clk_id=%v tp=%v, (%v:)", t, clk_id, tp, origin(2)) + } + var u64 uint64 // [100ns] + procGetSystemTimeAsFileTime.Call(uintptr(unsafe.Pointer(&u64)), 0, 0) + (*Timespec)(unsafe.Pointer(tp)).Ftv_sec = time.Time_t((u64/10 - 11644473600000000) / 1e6) + (*Timespec)(unsafe.Pointer(tp)).Ftv_nsec = int32((u64 * 100) % 1e9) + return 0 } // int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen); @@ -1770,14 +1797,6 @@ func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr { return resolved_path } -// struct tm *gmtime_r(const time_t *timep, struct tm *result); -func Xgmtime_r(t *TLS, timep, result uintptr) uintptr { - if __ccgo_strace { - trc("t=%v result=%v, (%v:)", t, result, origin(2)) - } - panic(todo("")) -} - // // char *inet_ntoa(struct in_addr in); // func Xinet_ntoa(t *TLS, in1 in.In_addr) uintptr { // panic(todo("")) @@ -7108,22 +7127,49 @@ func Xsscanf(t *TLS, str, format, va uintptr) int32 { return r } +var _toint4 = Float64FromInt32(1) / Float64FromFloat64(2.220446049250313e-16) + func Xrint(tls *TLS, x float64) float64 { if __ccgo_strace { trc("tls=%v x=%v, (%v:)", tls, x, origin(2)) } - switch { - case x == 0: // also +0 and -0 - return 0 - case math.IsInf(x, 0), math.IsNaN(x): - return x - case x >= math.MinInt64 && x <= math.MaxInt64 && float64(int64(x)) == x: + bp := tls.Alloc(16) + defer tls.Free(16) + var e, s int32 + var y Tdouble_t + var v1 float64 + var _ /* u at bp+0 */ struct { + Fi [0]Tuint64_t + Ff float64 + } + _, _, _, _ = e, s, y, v1 + *(*struct { + Fi [0]Tuint64_t + Ff float64 + })(unsafe.Pointer(bp)) = struct { + Fi [0]Tuint64_t + Ff float64 + }{} + *(*float64)(unsafe.Pointer(bp)) = x + e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) + s = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) + if e >= Int32FromInt32(0x3ff)+Int32FromInt32(52) { return x - case x >= 0: - return math.Floor(x + 0.5) - default: - return math.Ceil(x - 0.5) } + if s != 0 { + y = x - _toint4 + _toint4 + } else { + y = x + _toint4 - _toint4 + } + if y == Float64FromInt32(0) { + if s != 0 { + v1 = -Float64FromFloat64(0) + } else { + v1 = Float64FromInt32(0) + } + return v1 + } + return y } // FILE *fdopen(int fd, const char *mode); @@ -7471,15 +7517,131 @@ func AtomicLoadNUint8(ptr uintptr, memorder int32) uint8 { } // struct tm *gmtime( const time_t *sourceTime ); -func Xgmtime(t *TLS, sourceTime uintptr) uintptr { +// func Xgmtime(t *TLS, sourceTime uintptr) uintptr { +// if __ccgo_strace { +// trc("t=%v sourceTime=%v, (%v:)", t, sourceTime, origin(2)) +// } +// r0, _, err := procGmtime.Call(uintptr(sourceTime)) +// if err != windows.NOERROR { +// t.setErrno(err) +// } +// return uintptr(r0) +// } + +var _tm time.Tm + +// /tmp/libc/musl-master/src/time/gmtime.c:4:11: +func Xgmtime(tls *TLS, t uintptr) (r uintptr) { // /tmp/libc/musl-master/src/time/gmtime.c:7:2: if __ccgo_strace { - trc("t=%v sourceTime=%v, (%v:)", t, sourceTime, origin(2)) + trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) + defer func() { trc("-> %v", r) }() } - r0, _, err := procGmtime.Call(uintptr(sourceTime)) - if err != windows.NOERROR { - t.setErrno(err) + r = Xgmtime_r(tls, t, uintptr(unsafe.Pointer(&_tm))) + return r +} + +var _days_in_month = [12]int8{ + 0: int8(31), + 1: int8(30), + 2: int8(31), + 3: int8(30), + 4: int8(31), + 5: int8(31), + 6: int8(30), + 7: int8(31), + 8: int8(30), + 9: int8(31), + 10: int8(31), + 11: int8(29), +} + +var x___utc = [4]int8{'U', 'T', 'C'} + +func Xgmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { + if __ccgo_strace { + trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) + defer func() { trc("-> %v", r) }() } - return uintptr(r0) + if x___secs_to_tm(tls, int64(*(*time.Time_t)(unsafe.Pointer(t))), tm) < 0 { + *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(errno.EOVERFLOW) + return uintptr(0) + } + (*time.Tm)(unsafe.Pointer(tm)).Ftm_isdst = 0 + return tm +} + +func x___secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { + var c_cycles, leap, months, q_cycles, qc_cycles, remdays, remsecs, remyears, wday, yday int32 + var days, secs, years int64 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c_cycles, days, leap, months, q_cycles, qc_cycles, remdays, remsecs, remyears, secs, wday, yday, years + /* Reject time_t values whose year would overflow int */ + if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || t > Int64FromInt32(limits.INT_MAX)*Int64FromInt64(31622400) { + return -int32(1) + } + secs = t - (Int64FromInt64(946684800) + int64(Int32FromInt32(86400)*(Int32FromInt32(31)+Int32FromInt32(29)))) + days = secs / int64(86400) + remsecs = int32(secs % int64(86400)) + if remsecs < 0 { + remsecs += int32(86400) + days-- + } + wday = int32((int64(3) + days) % int64(7)) + if wday < 0 { + wday += int32(7) + } + qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) + remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) + if remdays < 0 { + remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) + qc_cycles-- + } + c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + if c_cycles == int32(4) { + c_cycles-- + } + remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + if q_cycles == int32(25) { + q_cycles-- + } + remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remyears = remdays / int32(365) + if remyears == int32(4) { + remyears-- + } + remdays -= remyears * int32(365) + leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) + yday = remdays + int32(31) + int32(28) + leap + if yday >= int32(365)+leap { + yday -= int32(365) + leap + } + years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(int64(qc_cycles)) + months = 0 + for { + if !(int32(_days_in_month[months]) <= remdays) { + break + } + remdays -= int32(_days_in_month[months]) + goto _1 + _1: + months++ + } + if months >= int32(10) { + months -= int32(12) + years++ + } + if years+int64(100) > int64(limits.INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { + return -int32(1) + } + (*time.Tm)(unsafe.Pointer(tm)).Ftm_year = int32(years + int64(100)) + (*time.Tm)(unsafe.Pointer(tm)).Ftm_mon = months + int32(2) + (*time.Tm)(unsafe.Pointer(tm)).Ftm_mday = remdays + int32(1) + (*time.Tm)(unsafe.Pointer(tm)).Ftm_wday = wday + (*time.Tm)(unsafe.Pointer(tm)).Ftm_yday = yday + (*time.Tm)(unsafe.Pointer(tm)).Ftm_hour = remsecs / int32(3600) + (*time.Tm)(unsafe.Pointer(tm)).Ftm_min = remsecs / int32(60) % int32(60) + (*time.Tm)(unsafe.Pointer(tm)).Ftm_sec = remsecs % int32(60) + return 0 } // size_t strftime( @@ -7609,3 +7771,7 @@ func X_strnicmp(tls *TLS, __Str1 uintptr, __Str2 uintptr, __MaxCount types.Size_ } return int32(r0) } + +func X__builtin_ctz(t *TLS, n uint32) int32 { + return int32(mbits.TrailingZeros32(n)) +} diff --git a/vendor/modernc.org/libc/mem.go b/vendor/modernc.org/libc/mem.go index df852c2d6..c8a4f7fe7 100644 --- a/vendor/modernc.org/libc/mem.go +++ b/vendor/modernc.org/libc/mem.go @@ -24,7 +24,9 @@ func Xmalloc(t *TLS, n types.Size_t) uintptr { trc("t=%v n=%v, (%v:)", t, n, origin(2)) } if n == 0 { - return 0 + // malloc(0) should return unique pointers + // (often expected and gnulib replaces malloc if malloc(0) returns 0) + n = 1 } allocMu.Lock() @@ -43,18 +45,18 @@ func Xmalloc(t *TLS, n types.Size_t) uintptr { // void *calloc(size_t nmemb, size_t size); func Xcalloc(t *TLS, n, size types.Size_t) uintptr { if __ccgo_strace { - trc("t=%v size=%v, (%v:)", t, size, origin(2)) + trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } rq := int(n * size) if rq == 0 { - return 0 + rq = 1 } allocMu.Lock() defer allocMu.Unlock() - p, err := allocator.UintptrCalloc(int(n * size)) + p, err := allocator.UintptrCalloc(rq) if err != nil { t.setErrno(errno.ENOMEM) return 0 diff --git a/vendor/modernc.org/libc/mem_brk.go b/vendor/modernc.org/libc/mem_brk.go index eb2032dba..4a76fab7b 100644 --- a/vendor/modernc.org/libc/mem_brk.go +++ b/vendor/modernc.org/libc/mem_brk.go @@ -35,7 +35,9 @@ func Xmalloc(t *TLS, n types.Size_t) uintptr { trc("t=%v n=%v, (%v:)", t, n, origin(2)) } if n == 0 { - return 0 + // malloc(0) should return unique pointers + // (often expected and gnulib replaces malloc if malloc(0) returns 0) + n = 1 } allocMu.Lock() @@ -57,7 +59,7 @@ func Xmalloc(t *TLS, n types.Size_t) uintptr { // void *calloc(size_t nmemb, size_t size); func Xcalloc(t *TLS, n, size types.Size_t) uintptr { if __ccgo_strace { - trc("t=%v size=%v, (%v:)", t, size, origin(2)) + trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } return Xmalloc(t, n*size) } diff --git a/vendor/modernc.org/libc/memgrind.go b/vendor/modernc.org/libc/memgrind.go index ccf5d8a3e..d525fa293 100644 --- a/vendor/modernc.org/libc/memgrind.go +++ b/vendor/modernc.org/libc/memgrind.go @@ -77,7 +77,9 @@ func Xmalloc(t *TLS, size types.Size_t) uintptr { trc("t=%v size=%v, (%v:)", t, size, origin(2)) } if size == 0 { - return 0 + // malloc(0) should return unique pointers + // (often expected and gnulib replaces malloc if malloc(0) returns 0) + size = 1 } allocMu.Lock() @@ -113,18 +115,18 @@ func Xmalloc(t *TLS, size types.Size_t) uintptr { // void *calloc(size_t nmemb, size_t size); func Xcalloc(t *TLS, n, size types.Size_t) uintptr { if __ccgo_strace { - trc("t=%v size=%v, (%v:)", t, size, origin(2)) + trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } rq := int(n * size) if rq == 0 { - return 0 + rq = 1 } allocMu.Lock() defer allocMu.Unlock() - p, err := allocator.UintptrCalloc(int(n * size)) + p, err := allocator.UintptrCalloc(rq) // if dmesgs { // dmesg("%v: %v -> %#x, %v", origin(1), n*size, p, err) // } @@ -269,6 +271,10 @@ func UsableSize(p uintptr) types.Size_t { return types.Size_t(memory.UintptrUsableSize(p)) } +func Xmalloc_usable_size(tls *TLS, p uintptr) (r Tsize_t) { + return UsableSize(p) +} + type MemAllocatorStat struct { Allocs int Bytes int diff --git a/vendor/modernc.org/libc/memgrind_musl.go b/vendor/modernc.org/libc/memgrind_musl.go index 1dc25ef2f..ee7c2dcf0 100644 --- a/vendor/modernc.org/libc/memgrind_musl.go +++ b/vendor/modernc.org/libc/memgrind_musl.go @@ -77,7 +77,9 @@ func Xmalloc(t *TLS, size Tsize_t) uintptr { trc("t=%v size=%v, (%v:)", t, size, origin(2)) } if size == 0 { - return 0 + // malloc(0) should return unique pointers + // (often expected and gnulib replaces malloc if malloc(0) returns 0) + size = 1 } allocatorMu.Lock() @@ -113,18 +115,18 @@ func Xmalloc(t *TLS, size Tsize_t) uintptr { // void *calloc(size_t nmemb, size_t size); func Xcalloc(t *TLS, n, size Tsize_t) uintptr { if __ccgo_strace { - trc("t=%v size=%v, (%v:)", t, size, origin(2)) + trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } rq := int(n * size) if rq == 0 { - return 0 + rq = 1 } allocatorMu.Lock() defer allocatorMu.Unlock() - p, err := allocator.UintptrCalloc(int(n * size)) + p, err := allocator.UintptrCalloc(rq) // if dmesgs { // dmesg("%v: %v -> %#x, %v", origin(1), n*size, p, err) // } diff --git a/vendor/modernc.org/libc/musl_darwin_amd64.go b/vendor/modernc.org/libc/musl_darwin_amd64.go index e0333fa3a..29081e450 100644 --- a/vendor/modernc.org/libc/musl_darwin_amd64.go +++ b/vendor/modernc.org/libc/musl_darwin_amd64.go @@ -357,7 +357,11 @@ type size_t = uint64 /* <builtin>:9:23 */ type wchar_t = int32 /* <builtin>:15:24 */ -var X__darwin_check_fd_set_overflow uintptr /* <builtin>:146:5: */ +// /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/_types/_fd_def.h:54 +// int __darwin_check_fd_set_overflow(int, const void *, int) __API_AVAILABLE(macosx(11.0), ios(14.0), tvos(14.0), watchos(7.0)); +func X__darwin_check_fd_set_overflow(tls *TLS, _ int32, _ uintptr, _ int32) int32 { + return 1 +} // pthread opaque structures diff --git a/vendor/modernc.org/libc/pthread.go b/vendor/modernc.org/libc/pthread.go index 3d8bc0b84..538766b2d 100644 --- a/vendor/modernc.org/libc/pthread.go +++ b/vendor/modernc.org/libc/pthread.go @@ -42,6 +42,7 @@ type TLS struct { jumpBuffers []uintptr lastError uint32 pthreadData + sp int stack stackHeader ID int32 @@ -67,6 +68,11 @@ func newTLS(detached bool) *TLS { return t } +// StackSlots reports the number of tls stack slots currently in use. +func (tls *TLS) StackSlots() int { + return tls.sp +} + func (t *TLS) alloca(n size_t) (r uintptr) { r = Xmalloc(t, n) t.allocas = append(t.allocas, r) @@ -183,7 +189,7 @@ func Xpthread_attr_setstacksize(t *TLS, attr uintptr, stackSize types.Size_t) in if __ccgo_strace { trc("t=%v attr=%v stackSize=%v, (%v:)", t, attr, stackSize, origin(2)) } - panic(todo("")) + return 0 } // Go side data of pthread_cond_t. diff --git a/vendor/modernc.org/libc/pthread_all.go b/vendor/modernc.org/libc/pthread_all.go index b5f0dfdcc..be50411ec 100644 --- a/vendor/modernc.org/libc/pthread_all.go +++ b/vendor/modernc.org/libc/pthread_all.go @@ -12,12 +12,16 @@ import ( "modernc.org/libc/pthread" ) +type pthreadAttr struct { + detachState int32 +} + // int pthread_attr_init(pthread_attr_t *attr); func Xpthread_attr_init(t *TLS, pAttr uintptr) int32 { if __ccgo_strace { trc("t=%v pAttr=%v, (%v:)", t, pAttr, origin(2)) } - *(*pthread.Pthread_attr_t)(unsafe.Pointer(pAttr)) = pthread.Pthread_attr_t{} + *(*pthreadAttr)(unsafe.Pointer(pAttr)) = pthreadAttr{} return 0 } diff --git a/vendor/modernc.org/libc/stdatomic.go b/vendor/modernc.org/libc/stdatomic.go index 7df65312a..bc718bb75 100644 --- a/vendor/modernc.org/libc/stdatomic.go +++ b/vendor/modernc.org/libc/stdatomic.go @@ -6,6 +6,7 @@ package libc // import "modernc.org/libc" import ( "sync" + "sync/atomic" "unsafe" ) @@ -21,6 +22,10 @@ var ( // { tmp = *ptr; *ptr op= val; return tmp; } // { tmp = *ptr; *ptr = ~(*ptr & val); return tmp; } // nand +func X__c11_atomic_fetch_addInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { + return X__atomic_fetch_addInt8(t, ptr, val, 0) +} + func X__atomic_fetch_addInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { int8Mu.Lock() @@ -31,6 +36,10 @@ func X__atomic_fetch_addInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { return r } +func X__c11_atomic_fetch_addUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { + return X__atomic_fetch_addUint8(t, ptr, val, 0) +} + func X__atomic_fetch_addUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { int8Mu.Lock() @@ -41,6 +50,10 @@ func X__atomic_fetch_addUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) return r } +func X__c11_atomic_fetch_addInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { + return X__atomic_fetch_addInt16(t, ptr, val, 0) +} + func X__atomic_fetch_addInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { int16Mu.Lock() @@ -51,6 +64,10 @@ func X__atomic_fetch_addInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) return r } +func X__c11_atomic_fetch_addUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { + return X__atomic_fetch_addUint16(t, ptr, val, 0) +} + func X__atomic_fetch_addUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { int16Mu.Lock() @@ -61,6 +78,10 @@ func X__atomic_fetch_addUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint return r } +func X__c11_atomic_fetch_addInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { + return X__atomic_fetch_addInt32(t, ptr, val, 0) +} + func X__atomic_fetch_addInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { int32Mu.Lock() @@ -71,6 +92,10 @@ func X__atomic_fetch_addInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) return r } +func X__c11_atomic_fetch_addUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { + return X__atomic_fetch_addUint32(t, ptr, val, 0) +} + func X__atomic_fetch_addUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { int32Mu.Lock() @@ -81,6 +106,10 @@ func X__atomic_fetch_addUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint return r } +func X__c11_atomic_fetch_addInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { + return X__atomic_fetch_addInt64(t, ptr, val, 0) +} + func X__atomic_fetch_addInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { int64Mu.Lock() @@ -91,6 +120,10 @@ func X__atomic_fetch_addInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) return r } +func X__c11_atomic_fetch_addUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { + return X__atomic_fetch_addUint64(t, ptr, val, 0) +} + func X__atomic_fetch_addUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { int64Mu.Lock() @@ -103,6 +136,10 @@ func X__atomic_fetch_addUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint // ---- +func X__c11_atomic_fetch_andInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { + return X__atomic_fetch_andInt8(t, ptr, val, 0) +} + func X__atomic_fetch_andInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { int8Mu.Lock() @@ -113,6 +150,10 @@ func X__atomic_fetch_andInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { return r } +func X__c11_atomic_fetch_andUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { + return X__atomic_fetch_andUint8(t, ptr, val, 0) +} + func X__atomic_fetch_andUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { int8Mu.Lock() @@ -123,6 +164,10 @@ func X__atomic_fetch_andUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) return r } +func X__c11_atomic_fetch_andInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { + return X__atomic_fetch_andInt16(t, ptr, val, 0) +} + func X__atomic_fetch_andInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { int16Mu.Lock() @@ -133,6 +178,10 @@ func X__atomic_fetch_andInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) return r } +func X__c11_atomic_fetch_andUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { + return X__atomic_fetch_andUint16(t, ptr, val, 0) +} + func X__atomic_fetch_andUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { int16Mu.Lock() @@ -143,6 +192,10 @@ func X__atomic_fetch_andUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint return r } +func X__c11_atomic_fetch_andInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { + return X__atomic_fetch_andInt32(t, ptr, val, 0) +} + func X__atomic_fetch_andInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { int32Mu.Lock() @@ -153,6 +206,10 @@ func X__atomic_fetch_andInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) return r } +func X__c11_atomic_fetch_andUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { + return X__atomic_fetch_andUint32(t, ptr, val, 0) +} + func X__atomic_fetch_andUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { int32Mu.Lock() @@ -163,6 +220,10 @@ func X__atomic_fetch_andUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint return r } +func X__c11_atomic_fetch_andInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { + return X__atomic_fetch_andInt64(t, ptr, val, 0) +} + func X__atomic_fetch_andInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { int64Mu.Lock() @@ -173,6 +234,10 @@ func X__atomic_fetch_andInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) return r } +func X__c11_atomic_fetch_andUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { + return X__atomic_fetch_andUint64(t, ptr, val, 0) +} + func X__atomic_fetch_andUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { int64Mu.Lock() @@ -185,6 +250,10 @@ func X__atomic_fetch_andUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint // ---- +func X__c11_atomic_fetch_orInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { + return X__atomic_fetch_orInt8(t, ptr, val, 0) +} + func X__atomic_fetch_orInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { int8Mu.Lock() @@ -195,6 +264,10 @@ func X__atomic_fetch_orInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { return r } +func X__c11_atomic_fetch_orUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { + return X__atomic_fetch_orUint8(t, ptr, val, 0) +} + func X__atomic_fetch_orUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { int8Mu.Lock() @@ -205,6 +278,10 @@ func X__atomic_fetch_orUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) return r } +func X__c11_atomic_fetch_orInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { + return X__atomic_fetch_orInt16(t, ptr, val, 0) +} + func X__atomic_fetch_orInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { int16Mu.Lock() @@ -215,6 +292,10 @@ func X__atomic_fetch_orInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) return r } +func X__c11_atomic_fetch_orUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { + return X__atomic_fetch_orUint16(t, ptr, val, 0) +} + func X__atomic_fetch_orUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { int16Mu.Lock() @@ -225,6 +306,10 @@ func X__atomic_fetch_orUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint1 return r } +func X__c11_atomic_fetch_orInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { + return X__atomic_fetch_orInt32(t, ptr, val, 0) +} + func X__atomic_fetch_orInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { int32Mu.Lock() @@ -235,6 +320,10 @@ func X__atomic_fetch_orInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) return r } +func X__c11_atomic_fetch_orUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { + return X__atomic_fetch_orUint32(t, ptr, val, 0) +} + func X__atomic_fetch_orUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { int32Mu.Lock() @@ -245,6 +334,10 @@ func X__atomic_fetch_orUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint3 return r } +func X__c11_atomic_fetch_orInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { + return X__atomic_fetch_orInt64(t, ptr, val, 0) +} + func X__atomic_fetch_orInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { int64Mu.Lock() @@ -255,6 +348,10 @@ func X__atomic_fetch_orInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) return r } +func X__c11_atomic_fetch_orUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { + return X__atomic_fetch_orUint64(t, ptr, val, 0) +} + func X__atomic_fetch_orUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { int64Mu.Lock() @@ -267,6 +364,10 @@ func X__atomic_fetch_orUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint6 // ---- +func X__c11_atomic_fetch_subInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { + return X__atomic_fetch_subInt8(t, ptr, val, 0) +} + func X__atomic_fetch_subInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { int8Mu.Lock() @@ -277,6 +378,10 @@ func X__atomic_fetch_subInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { return r } +func X__c11_atomic_fetch_subUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { + return X__atomic_fetch_subUint8(t, ptr, val, 0) +} + func X__atomic_fetch_subUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { int8Mu.Lock() @@ -287,6 +392,10 @@ func X__atomic_fetch_subUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) return r } +func X__c11_atomic_fetch_subInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { + return X__atomic_fetch_subInt16(t, ptr, val, 0) +} + func X__atomic_fetch_subInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { int16Mu.Lock() @@ -297,6 +406,10 @@ func X__atomic_fetch_subInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) return r } +func X__c11_atomic_fetch_subUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { + return X__atomic_fetch_subUint16(t, ptr, val, 0) +} + func X__atomic_fetch_subUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { int16Mu.Lock() @@ -307,6 +420,10 @@ func X__atomic_fetch_subUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint return r } +func X__c11_atomic_fetch_subInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { + return X__atomic_fetch_subInt32(t, ptr, val, 0) +} + func X__atomic_fetch_subInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { int32Mu.Lock() @@ -317,6 +434,10 @@ func X__atomic_fetch_subInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) return r } +func X__c11_atomic_fetch_subUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { + return X__atomic_fetch_subUint32(t, ptr, val, 0) +} + func X__atomic_fetch_subUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { int32Mu.Lock() @@ -327,6 +448,10 @@ func X__atomic_fetch_subUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint return r } +func X__c11_atomic_fetch_subInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { + return X__atomic_fetch_subInt64(t, ptr, val, 0) +} + func X__atomic_fetch_subInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { int64Mu.Lock() @@ -337,6 +462,10 @@ func X__atomic_fetch_subInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) return r } +func X__c11_atomic_fetch_subUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { + return X__atomic_fetch_subUint64(t, ptr, val, 0) +} + func X__atomic_fetch_subUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { int64Mu.Lock() @@ -349,6 +478,10 @@ func X__atomic_fetch_subUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint // ---- +func X__c11_atomic_fetch_xorInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { + return X__atomic_fetch_xorInt8(t, ptr, val, 0) +} + func X__atomic_fetch_xorInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { int8Mu.Lock() @@ -359,6 +492,10 @@ func X__atomic_fetch_xorInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { return r } +func X__c11_atomic_fetch_xorUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { + return X__atomic_fetch_xorUint8(t, ptr, val, 0) +} + func X__atomic_fetch_xorUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { int8Mu.Lock() @@ -369,6 +506,10 @@ func X__atomic_fetch_xorUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) return r } +func X__c11_atomic_fetch_xorInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { + return X__atomic_fetch_xorInt16(t, ptr, val, 0) +} + func X__atomic_fetch_xorInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { int16Mu.Lock() @@ -379,6 +520,10 @@ func X__atomic_fetch_xorInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) return r } +func X__c11_atomic_fetch_xorUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { + return X__atomic_fetch_xorUint16(t, ptr, val, 0) +} + func X__atomic_fetch_xorUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { int16Mu.Lock() @@ -389,6 +534,10 @@ func X__atomic_fetch_xorUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint return r } +func X__c11_atomic_fetch_xorInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { + return X__atomic_fetch_xorInt32(t, ptr, val, 0) +} + func X__atomic_fetch_xorInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { int32Mu.Lock() @@ -399,6 +548,10 @@ func X__atomic_fetch_xorInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) return r } +func X__c11_atomic_fetch_xorUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { + return X__atomic_fetch_xorUint32(t, ptr, val, 0) +} + func X__atomic_fetch_xorUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { int32Mu.Lock() @@ -409,6 +562,10 @@ func X__atomic_fetch_xorUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint return r } +func X__c11_atomic_fetch_xorInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { + return X__atomic_fetch_xorInt64(t, ptr, val, 0) +} + func X__atomic_fetch_xorInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { int64Mu.Lock() @@ -419,6 +576,10 @@ func X__atomic_fetch_xorInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) return r } +func X__c11_atomic_fetch_xorUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { + return X__atomic_fetch_xorUint64(t, ptr, val, 0) +} + func X__atomic_fetch_xorUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { int64Mu.Lock() @@ -433,6 +594,16 @@ func X__atomic_fetch_xorUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint // void __atomic_exchange (type *ptr, type *val, type *ret, int memorder) +func X__c11_atomic_exchangeInt8(t *TLS, ptr uintptr, val int8, _ int32) (r int8) { + int8Mu.Lock() + + defer int8Mu.Unlock() + + r = *(*int8)(unsafe.Pointer(ptr)) + *(*int8)(unsafe.Pointer(ptr)) = val + return r +} + func X__atomic_exchangeInt8(t *TLS, ptr, val, ret uintptr, _ int32) { int8Mu.Lock() @@ -442,6 +613,16 @@ func X__atomic_exchangeInt8(t *TLS, ptr, val, ret uintptr, _ int32) { *(*int8)(unsafe.Pointer(ptr)) = *(*int8)(unsafe.Pointer(val)) } +func X__c11_atomic_exchangeUint8(t *TLS, ptr uintptr, val uint8, _ int32) (r uint8) { + int8Mu.Lock() + + defer int8Mu.Unlock() + + r = *(*uint8)(unsafe.Pointer(ptr)) + *(*uint8)(unsafe.Pointer(ptr)) = val + return r +} + func X__atomic_exchangeUint8(t *TLS, ptr, val, ret uintptr, _ int32) { int8Mu.Lock() @@ -451,6 +632,16 @@ func X__atomic_exchangeUint8(t *TLS, ptr, val, ret uintptr, _ int32) { *(*uint8)(unsafe.Pointer(ptr)) = *(*uint8)(unsafe.Pointer(val)) } +func X__c11_atomic_exchangeInt16(t *TLS, ptr uintptr, val int16, _ int32) (r int16) { + int16Mu.Lock() + + defer int16Mu.Unlock() + + r = *(*int16)(unsafe.Pointer(ptr)) + *(*int16)(unsafe.Pointer(ptr)) = val + return r +} + func X__atomic_exchangeInt16(t *TLS, ptr, val, ret uintptr, _ int32) { int16Mu.Lock() @@ -460,6 +651,16 @@ func X__atomic_exchangeInt16(t *TLS, ptr, val, ret uintptr, _ int32) { *(*int16)(unsafe.Pointer(ptr)) = *(*int16)(unsafe.Pointer(val)) } +func X__c11_atomic_exchangeUint16(t *TLS, ptr uintptr, val uint16, _ int32) (r uint16) { + int16Mu.Lock() + + defer int16Mu.Unlock() + + r = *(*uint16)(unsafe.Pointer(ptr)) + *(*uint16)(unsafe.Pointer(ptr)) = val + return r +} + func X__atomic_exchangeUint16(t *TLS, ptr, val, ret uintptr, _ int32) { int16Mu.Lock() @@ -469,40 +670,36 @@ func X__atomic_exchangeUint16(t *TLS, ptr, val, ret uintptr, _ int32) { *(*uint16)(unsafe.Pointer(ptr)) = *(*uint16)(unsafe.Pointer(val)) } -func X__atomic_exchangeInt32(t *TLS, ptr, val, ret uintptr, _ int32) { - int32Mu.Lock() +func X__c11_atomic_exchangeInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { + return atomic.SwapInt32((*int32)(unsafe.Pointer(ptr)), val) +} - defer int32Mu.Unlock() +func X__atomic_exchangeInt32(t *TLS, ptr, val, ret uintptr, _ int32) { + *(*int32)(unsafe.Pointer(ret)) = atomic.SwapInt32((*int32)(unsafe.Pointer(ptr)), *(*int32)(unsafe.Pointer(val))) +} - *(*int32)(unsafe.Pointer(ret)) = *(*int32)(unsafe.Pointer(ptr)) - *(*int32)(unsafe.Pointer(ptr)) = *(*int32)(unsafe.Pointer(val)) +func X__c11_atomic_exchangeUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { + return uint32(atomic.SwapInt32((*int32)(unsafe.Pointer(ptr)), int32(val))) } func X__atomic_exchangeUint32(t *TLS, ptr, val, ret uintptr, _ int32) { - int32Mu.Lock() - - defer int32Mu.Unlock() + *(*uint32)(unsafe.Pointer(ret)) = atomic.SwapUint32((*uint32)(unsafe.Pointer(ptr)), *(*uint32)(unsafe.Pointer(val))) +} - *(*uint32)(unsafe.Pointer(ret)) = *(*uint32)(unsafe.Pointer(ptr)) - *(*uint32)(unsafe.Pointer(ptr)) = *(*uint32)(unsafe.Pointer(val)) +func X__c11_atomic_exchangeInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { + return atomic.SwapInt64((*int64)(unsafe.Pointer(ptr)), val) } func X__atomic_exchangeInt64(t *TLS, ptr, val, ret uintptr, _ int32) { - int64Mu.Lock() - - defer int64Mu.Unlock() + *(*int64)(unsafe.Pointer(ret)) = atomic.SwapInt64((*int64)(unsafe.Pointer(ptr)), *(*int64)(unsafe.Pointer(val))) +} - *(*int64)(unsafe.Pointer(ret)) = *(*int64)(unsafe.Pointer(ptr)) - *(*int64)(unsafe.Pointer(ptr)) = *(*int64)(unsafe.Pointer(val)) +func X__c11_atomic_exchangeUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { + return uint64(atomic.SwapInt64((*int64)(unsafe.Pointer(ptr)), int64(val))) } func X__atomic_exchangeUint64(t *TLS, ptr, val, ret uintptr, _ int32) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - *(*uint64)(unsafe.Pointer(ret)) = *(*uint64)(unsafe.Pointer(ptr)) - *(*uint64)(unsafe.Pointer(ptr)) = *(*uint64)(unsafe.Pointer(val)) + *(*uint64)(unsafe.Pointer(ret)) = atomic.SwapUint64((*uint64)(unsafe.Pointer(ptr)), *(*uint64)(unsafe.Pointer(val))) } // ---- @@ -605,10 +802,94 @@ func X__atomic_compare_exchangeUint64(t *TLS, ptr, expected, desired uintptr, we return X__atomic_compare_exchangeInt64(t, ptr, expected, desired, weak, success, failure) } +func X__c11_atomic_compare_exchange_strongInt8(t *TLS, ptr, expected uintptr, desired int8, success, failure int32) int32 { + int8Mu.Lock() + + defer int8Mu.Unlock() + + have := *(*int8)(unsafe.Pointer(ptr)) + if have == *(*int8)(unsafe.Pointer(expected)) { + *(*int8)(unsafe.Pointer(ptr)) = desired + return 1 + } + + *(*int8)(unsafe.Pointer(expected)) = have + return 0 +} + +func X__c11_atomic_compare_exchange_strongUint8(t *TLS, ptr, expected uintptr, desired uint8, success, failure int32) int32 { + return X__c11_atomic_compare_exchange_strongInt8(t, ptr, expected, int8(desired), success, failure) +} + +func X__c11_atomic_compare_exchange_strongInt16(t *TLS, ptr, expected uintptr, desired int16, success, failure int32) int32 { + int16Mu.Lock() + + defer int16Mu.Unlock() + + have := *(*int16)(unsafe.Pointer(ptr)) + if have == *(*int16)(unsafe.Pointer(expected)) { + *(*int16)(unsafe.Pointer(ptr)) = desired + return 1 + } + + *(*int16)(unsafe.Pointer(expected)) = have + return 0 +} + +func X__c11_atomic_compare_exchange_strongUint16(t *TLS, ptr, expected uintptr, desired uint16, success, failure int32) int32 { + return X__c11_atomic_compare_exchange_strongInt16(t, ptr, expected, int16(desired), success, failure) +} + +func X__c11_atomic_compare_exchange_strongInt32(t *TLS, ptr, expected uintptr, desired, success, failure int32) int32 { + int32Mu.Lock() + + defer int32Mu.Unlock() + + have := *(*int32)(unsafe.Pointer(ptr)) + if have == *(*int32)(unsafe.Pointer(expected)) { + *(*int32)(unsafe.Pointer(ptr)) = desired + return 1 + } + + *(*int32)(unsafe.Pointer(expected)) = have + return 0 +} + +func X__c11_atomic_compare_exchange_strongUint32(t *TLS, ptr, expected uintptr, desired uint32, success, failure int32) int32 { + return X__c11_atomic_compare_exchange_strongInt32(t, ptr, expected, int32(desired), success, failure) +} + +func X__c11_atomic_compare_exchange_strongInt64(t *TLS, ptr, expected uintptr, desired int64, success, failure int32) int32 { + int64Mu.Lock() + + defer int64Mu.Unlock() + + have := *(*int64)(unsafe.Pointer(ptr)) + if have == *(*int64)(unsafe.Pointer(expected)) { + *(*int64)(unsafe.Pointer(ptr)) = desired + return 1 + } + + *(*int64)(unsafe.Pointer(expected)) = have + return 0 +} + +func X__c11_atomic_compare_exchange_strongUint64(t *TLS, ptr, expected uintptr, desired uint64, success, failure int32) int32 { + return X__c11_atomic_compare_exchange_strongInt64(t, ptr, expected, int64(desired), success, failure) +} + // ---- // void __atomic_load (type *ptr, type *ret, int memorder) +func X__c11_atomic_loadInt8(t *TLS, ptr uintptr, memorder int32) (r int8) { + int8Mu.Lock() + + defer int8Mu.Unlock() + + return *(*int8)(unsafe.Pointer(ptr)) +} + func X__atomic_loadInt8(t *TLS, ptr, ret uintptr, memorder int32) { int8Mu.Lock() @@ -617,10 +898,22 @@ func X__atomic_loadInt8(t *TLS, ptr, ret uintptr, memorder int32) { *(*int8)(unsafe.Pointer(ret)) = *(*int8)(unsafe.Pointer(ptr)) } +func X__c11_atomic_loadUint8(t *TLS, ptr uintptr, memorder int32) (r uint8) { + return uint8(X__c11_atomic_loadInt8(t, ptr, memorder)) +} + func X__atomic_loadUint8(t *TLS, ptr, ret uintptr, memorder int32) { X__atomic_loadInt8(t, ptr, ret, memorder) } +func X__c11_atomic_loadInt16(t *TLS, ptr uintptr, memorder int32) (r int16) { + int16Mu.Lock() + + defer int16Mu.Unlock() + + return *(*int16)(unsafe.Pointer(ptr)) +} + func X__atomic_loadInt16(t *TLS, ptr, ret uintptr, memorder int32) { int16Mu.Lock() @@ -629,28 +922,40 @@ func X__atomic_loadInt16(t *TLS, ptr, ret uintptr, memorder int32) { *(*int16)(unsafe.Pointer(ret)) = *(*int16)(unsafe.Pointer(ptr)) } +func X__c11_atomic_loadUint16(t *TLS, ptr uintptr, memorder int32) (r uint16) { + return uint16(X__c11_atomic_loadInt16(t, ptr, memorder)) +} + func X__atomic_loadUint16(t *TLS, ptr, ret uintptr, memorder int32) { X__atomic_loadInt16(t, ptr, ret, memorder) } -func X__atomic_loadInt32(t *TLS, ptr, ret uintptr, memorder int32) { - int32Mu.Lock() +func X__c11_atomic_loadInt32(t *TLS, ptr uintptr, memorder int32) (r int32) { + return atomic.LoadInt32((*int32)(unsafe.Pointer(ptr))) +} - defer int32Mu.Unlock() +func X__atomic_loadInt32(t *TLS, ptr, ret uintptr, memorder int32) { + *(*int32)(unsafe.Pointer(ret)) = atomic.LoadInt32((*int32)(unsafe.Pointer(ptr))) +} - *(*int32)(unsafe.Pointer(ret)) = *(*int32)(unsafe.Pointer(ptr)) +func X__c11_atomic_loadUint32(t *TLS, ptr uintptr, memorder int32) (r uint32) { + return uint32(X__c11_atomic_loadInt32(t, ptr, memorder)) } func X__atomic_loadUint32(t *TLS, ptr, ret uintptr, memorder int32) { X__atomic_loadInt32(t, ptr, ret, memorder) } -func X__atomic_loadInt64(t *TLS, ptr, ret uintptr, memorder int32) { - int64Mu.Lock() +func X__c11_atomic_loadInt64(t *TLS, ptr uintptr, memorder int32) (r int64) { + return atomic.LoadInt64((*int64)(unsafe.Pointer(ptr))) +} - defer int64Mu.Unlock() +func X__atomic_loadInt64(t *TLS, ptr, ret uintptr, memorder int32) { + *(*int64)(unsafe.Pointer(ret)) = atomic.LoadInt64((*int64)(unsafe.Pointer(ptr))) +} - *(*int64)(unsafe.Pointer(ret)) = *(*int64)(unsafe.Pointer(ptr)) +func X__c11_atomic_loadUint64(t *TLS, ptr uintptr, memorder int32) (r uint64) { + return uint64(X__c11_atomic_loadInt64(t, ptr, memorder)) } func X__atomic_loadUint64(t *TLS, ptr, ret uintptr, memorder int32) { @@ -661,6 +966,14 @@ func X__atomic_loadUint64(t *TLS, ptr, ret uintptr, memorder int32) { // void __atomic_store (type *ptr, type *val, int memorder) +func X__c11_atomic_storeInt8(t *TLS, ptr uintptr, val int8, memorder int32) { + int8Mu.Lock() + + defer int8Mu.Unlock() + + *(*int8)(unsafe.Pointer(ptr)) = val +} + func X__atomic_storeInt8(t *TLS, ptr, val uintptr, memorder int32) { int8Mu.Lock() @@ -669,10 +982,22 @@ func X__atomic_storeInt8(t *TLS, ptr, val uintptr, memorder int32) { *(*int8)(unsafe.Pointer(ptr)) = *(*int8)(unsafe.Pointer(val)) } +func X__c11_atomic_storeUint8(t *TLS, ptr uintptr, val uint8, memorder int32) { + X__c11_atomic_storeInt8(t, ptr, int8(val), memorder) +} + func X__atomic_storeUint8(t *TLS, ptr, val uintptr, memorder int32) { X__atomic_storeInt8(t, ptr, val, memorder) } +func X__c11_atomic_storeInt16(t *TLS, ptr uintptr, val int16, memorder int32) { + int16Mu.Lock() + + defer int16Mu.Unlock() + + *(*int16)(unsafe.Pointer(ptr)) = val +} + func X__atomic_storeInt16(t *TLS, ptr, val uintptr, memorder int32) { int16Mu.Lock() @@ -681,30 +1006,139 @@ func X__atomic_storeInt16(t *TLS, ptr, val uintptr, memorder int32) { *(*int16)(unsafe.Pointer(ptr)) = *(*int16)(unsafe.Pointer(val)) } +func X__c11_atomic_storeUint16(t *TLS, ptr uintptr, val uint16, memorder int32) { + X__c11_atomic_storeInt16(t, ptr, int16(val), memorder) +} + func X__atomic_storeUint16(t *TLS, ptr, val uintptr, memorder int32) { X__atomic_storeInt16(t, ptr, val, memorder) } -func X__atomic_storeInt32(t *TLS, ptr, val uintptr, memorder int32) { - int32Mu.Lock() +func X__c11_atomic_storeInt32(t *TLS, ptr uintptr, val int32, memorder int32) { + atomic.StoreInt32((*int32)(unsafe.Pointer(ptr)), val) +} - defer int32Mu.Unlock() +func X__atomic_storeInt32(t *TLS, ptr, val uintptr, memorder int32) { + atomic.StoreInt32((*int32)(unsafe.Pointer(ptr)), *(*int32)(unsafe.Pointer(val))) +} - *(*int32)(unsafe.Pointer(ptr)) = *(*int32)(unsafe.Pointer(val)) +func X__c11_atomic_storeUint32(t *TLS, ptr uintptr, val uint32, memorder int32) { + X__c11_atomic_storeInt32(t, ptr, int32(val), memorder) } func X__atomic_storeUint32(t *TLS, ptr, val uintptr, memorder int32) { X__atomic_storeInt32(t, ptr, val, memorder) } +func X__c11_atomic_storeInt64(t *TLS, ptr uintptr, val int64, memorder int32) { + atomic.StoreInt64((*int64)(unsafe.Pointer(ptr)), val) +} + func X__atomic_storeInt64(t *TLS, ptr, val uintptr, memorder int32) { + atomic.StoreInt64((*int64)(unsafe.Pointer(ptr)), *(*int64)(unsafe.Pointer(val))) +} + +func X__c11_atomic_storeUint64(t *TLS, ptr uintptr, val uint64, memorder int32) { + X__c11_atomic_storeInt64(t, ptr, int64(val), memorder) +} + +func X__atomic_storeUint64(t *TLS, ptr, val uintptr, memorder int32) { + X__atomic_storeInt64(t, ptr, val, memorder) +} + +// type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...) +func X__sync_val_compare_and_swapInt8(t *TLS, ptr uintptr, oldval, newval int8) (r int8) { + int8Mu.Lock() + + defer int8Mu.Unlock() + + if r = *(*int8)(unsafe.Pointer(ptr)); r == oldval { + *(*int8)(unsafe.Pointer(ptr)) = newval + } + + return r +} + +func X__sync_val_compare_and_swapUint8(t *TLS, ptr uintptr, oldval, newval uint8) (r uint8) { + int8Mu.Lock() + + defer int8Mu.Unlock() + + if r = *(*uint8)(unsafe.Pointer(ptr)); r == oldval { + *(*uint8)(unsafe.Pointer(ptr)) = newval + } + + return r +} + +func X__sync_val_compare_and_swapInt16(t *TLS, ptr uintptr, oldval, newval int16) (r int16) { + int16Mu.Lock() + + defer int16Mu.Unlock() + + if r = *(*int16)(unsafe.Pointer(ptr)); r == oldval { + *(*int16)(unsafe.Pointer(ptr)) = newval + } + + return r +} + +func X__sync_val_compare_and_swapUint16(t *TLS, ptr uintptr, oldval, newval uint16) (r uint16) { + int16Mu.Lock() + + defer int16Mu.Unlock() + + if r = *(*uint16)(unsafe.Pointer(ptr)); r == oldval { + *(*uint16)(unsafe.Pointer(ptr)) = newval + } + + return r +} + +func X__sync_val_compare_and_swapInt32(t *TLS, ptr uintptr, oldval, newval int32) (r int32) { + int32Mu.Lock() + + defer int32Mu.Unlock() + + if r = *(*int32)(unsafe.Pointer(ptr)); r == oldval { + *(*int32)(unsafe.Pointer(ptr)) = newval + } + + return r +} + +func X__sync_val_compare_and_swapUint32(t *TLS, ptr uintptr, oldval, newval uint32) (r uint32) { + int32Mu.Lock() + + defer int32Mu.Unlock() + + if r = *(*uint32)(unsafe.Pointer(ptr)); r == oldval { + *(*uint32)(unsafe.Pointer(ptr)) = newval + } + + return r +} + +func X__sync_val_compare_and_swapInt64(t *TLS, ptr uintptr, oldval, newval int64) (r int64) { int64Mu.Lock() defer int64Mu.Unlock() - *(*int64)(unsafe.Pointer(ptr)) = *(*int64)(unsafe.Pointer(val)) + if r = *(*int64)(unsafe.Pointer(ptr)); r == oldval { + *(*int64)(unsafe.Pointer(ptr)) = newval + } + + return r } -func X__atomic_storeUint64(t *TLS, ptr, val uintptr, memorder int32) { - X__atomic_storeInt64(t, ptr, val, memorder) +func X__sync_val_compare_and_swapUint64(t *TLS, ptr uintptr, oldval, newval uint64) (r uint64) { + int64Mu.Lock() + + defer int64Mu.Unlock() + + if r = *(*uint64)(unsafe.Pointer(ptr)); r == oldval { + *(*uint64)(unsafe.Pointer(ptr)) = newval + } + + return r } diff --git a/vendor/modernc.org/libc/unconvert.sh b/vendor/modernc.org/libc/unconvert.sh deleted file mode 100644 index 93fba250f..000000000 --- a/vendor/modernc.org/libc/unconvert.sh +++ /dev/null @@ -1,6 +0,0 @@ -set -evx -until unconvert -fastmath ./... -do - unconvert -fastmath -apply ./... -done -git checkout -f pthread_musl.go |