From cc1241f353abbac2df2baf7abe09506be27782e8 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Fri, 27 Feb 2026 14:57:48 -0500 Subject: runtime: fix printfloat, printcomplex buffer sizes The buffers added in CL 716002 for printfloat64 and printcomplex128 are too small to fit the longest formatted values. For values that are too long, AppendFloat allocates, which may cause a crash for prints in places in the runtime where allocation is not allowed. Fixes #77854. Change-Id: I6a6a636cc2fc5cae9fda25f10b28fd641aa1ff28 Reviewed-on: https://go-review.googlesource.com/c/go/+/749947 Reviewed-by: Russ Cox Auto-Submit: Michael Pratt LUCI-TryBot-Result: Go LUCI Reviewed-by: Michael Knyszek --- src/runtime/export_test.go | 18 +++++++++++++ src/runtime/print.go | 20 +++++++++++--- src/runtime/print_test.go | 65 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+), 4 deletions(-) create mode 100644 src/runtime/print_test.go (limited to 'src/runtime') diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go index f71494174c..bc471e50a0 100644 --- a/src/runtime/export_test.go +++ b/src/runtime/export_test.go @@ -2084,6 +2084,24 @@ func DumpPrintQuoted(s string) string { return string(buf) } +// DumpPrint returns the output of print(v). +func DumpPrint[T any](v T) string { + gp := getg() + gp.writebuf = make([]byte, 0, 2048) + print(v) + buf := gp.writebuf + gp.writebuf = nil + + return string(buf) +} + +var ( + Float64Bytes = float64Bytes + Float32Bytes = float32Bytes + Complex128Bytes = complex128Bytes + Complex64Bytes = complex64Bytes +) + func GetScanAlloc() uintptr { c := getMCache(getg().m) return c.scanAlloc diff --git a/src/runtime/print.go b/src/runtime/print.go index c8ce96546d..3abdf17ad8 100644 --- a/src/runtime/print.go +++ b/src/runtime/print.go @@ -122,23 +122,35 @@ func printbool(v bool) { } } +// float64 requires 1+17+1+1+1+3 = 24 bytes max (sign+digits+decimal point+e+sign+exponent digits). +const float64Bytes = 24 + func printfloat64(v float64) { - var buf [20]byte + var buf [float64Bytes]byte gwrite(strconv.AppendFloat(buf[:0], v, 'g', -1, 64)) } +// float32 requires 1+9+1+1+1+2 = 15 bytes max (sign+digits+decimal point+e+sign+exponent digits). +const float32Bytes = 15 + func printfloat32(v float32) { - var buf [20]byte + var buf [float32Bytes]byte gwrite(strconv.AppendFloat(buf[:0], float64(v), 'g', -1, 32)) } +// complex128 requires 24+24+1+1+1 = 51 bytes max (paren+float64+float64+i+paren). +const complex128Bytes = 2*float64Bytes + 3 + func printcomplex128(c complex128) { - var buf [44]byte + var buf [complex128Bytes]byte gwrite(strconv.AppendComplex(buf[:0], c, 'g', -1, 128)) } +// complex64 requires 15+15+1+1+1 = 33 bytes max (paren+float32+float32+i+paren). +const complex64Bytes = 2*float32Bytes + 3 + func printcomplex64(c complex64) { - var buf [44]byte + var buf [complex64Bytes]byte gwrite(strconv.AppendComplex(buf[:0], complex128(c), 'g', -1, 64)) } diff --git a/src/runtime/print_test.go b/src/runtime/print_test.go new file mode 100644 index 0000000000..cfc27ed95b --- /dev/null +++ b/src/runtime/print_test.go @@ -0,0 +1,65 @@ +// Copyright 2026 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package runtime_test + +import ( + "math" + "runtime" + "testing" +) + +func FuzzPrintFloat64(f *testing.F) { + f.Add(math.SmallestNonzeroFloat64) + f.Add(math.MaxFloat64) + f.Add(-1.7976931348623157e+308) // requires 24 digits + + f.Fuzz(func(t *testing.T, v float64) { + s := runtime.DumpPrint(v) + if len(s) > runtime.Float64Bytes { + t.Errorf("print(%f) got %s (len %d) want len <= %d", v, s, len(s), runtime.Float64Bytes) + } + }) +} + +func FuzzPrintFloat32(f *testing.F) { + f.Add(float32(math.SmallestNonzeroFloat32)) + f.Add(float32(math.MaxFloat32)) + f.Add(float32(-1.06338233e+37)) // requires 15 digits + + f.Fuzz(func(t *testing.T, v float32) { + s := runtime.DumpPrint(v) + if len(s) > runtime.Float32Bytes { + t.Errorf("print(%f) got %s (len %d) want len <= %d", v, s, len(s), runtime.Float32Bytes) + } + }) +} + +func FuzzPrintComplex128(f *testing.F) { + f.Add(math.SmallestNonzeroFloat64, math.SmallestNonzeroFloat64) + f.Add(math.MaxFloat64, math.MaxFloat64) + f.Add(-1.7976931348623157e+308, -1.7976931348623157e+308) // requires 51 digits + + f.Fuzz(func(t *testing.T, r, i float64) { + v := complex(r, i) + s := runtime.DumpPrint(v) + if len(s) > runtime.Complex128Bytes { + t.Errorf("print(%f) got %s (len %d) want len <= %d", v, s, len(s), runtime.Complex128Bytes) + } + }) +} + +func FuzzPrintComplex64(f *testing.F) { + f.Add(float32(math.SmallestNonzeroFloat32), float32(math.SmallestNonzeroFloat32)) + f.Add(float32(math.MaxFloat32), float32(math.MaxFloat32)) + f.Add(float32(-1.06338233e+37), float32(-1.06338233e+37)) // requires 33 digits + + f.Fuzz(func(t *testing.T, r, i float32) { + v := complex(r, i) + s := runtime.DumpPrint(v) + if len(s) > runtime.Complex64Bytes { + t.Errorf("print(%f) got %s (len %d) want len <= %d", v, s, len(s), runtime.Complex64Bytes) + } + }) +} -- cgit v1.3