@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/internal/strconv/ftoa.go

@@ -10,29 +10,26 @@
 
 package strconv
 
+import (
+	"math/bits"
+	"unsafe"
+)
+
 const (
 	lowerhex = "0123456789abcdef"
 	upperhex = "0123456789ABCDEF"
 )
 
-type floatInfo struct {
-	mantbits uint
-	expbits  uint
-	bias     int
-}
-
 const (
 	float32MantBits = 23
 	float32ExpBits  = 8
 	float32Bias     = -127
+	float32MinExp   = -189
+
 	float64MantBits = 52
 	float64ExpBits  = 11
 	float64Bias     = -1023
-)
-
-var (
-	float32info = floatInfo{float32MantBits, float32ExpBits, float32Bias}
-	float64info = floatInfo{float64MantBits, float64ExpBits, float64Bias}
+	float64MinExp   = -1085
 )
 
 // FormatFloat converts the floating-point number f to a string,
@@ -60,179 +57,299 @@ var (
 // The exponent is written as a decimal integer;
 // for all formats other than 'b', it will be at least two digits.
 func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
-	return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
+	if bitSize == 32 {
+		return string(ftoa32(make([]byte, 0, max(prec+4, 24)), float32(f), fmt, prec))
+	}
+	if bitSize == 64 {
+		return string(ftoa64(make([]byte, 0, max(prec+4, 24)), f, fmt, prec))
+	}
+	panic("strconv: illegal FormatFloat bitSize")
 }
 
 // AppendFloat appends the string form of the floating-point number f,
 // as generated by [FormatFloat], to dst and returns the extended buffer.
 func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte {
-	return genericFtoa(dst, f, fmt, prec, bitSize)
+	if bitSize == 32 {
+		return ftoa32(dst, float32(f), fmt, prec)
+	}
+	if bitSize == 64 {
+		return ftoa64(dst, f, fmt, prec)
+	}
+	panic("strconv: illegal AppendFloat bitSize")
 }
 
-func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
-	var bits uint64
-	var flt *floatInfo
-	switch bitSize {
+// TODO(rsc): This should be ftoa[F float32 | float64](dst []byte, val F, ...),
+// but due to some bad interaction between inlining, escape analysis, and generic functions,
+// the result appears to escape dst to the heap with -l=4, which breaks
+// TestAbstractOriginSanity. See go.dev/issue/79547.
+// For now we make two manual specializations ftoa32 and ftoa64 instead.
+
+func ftoa32(dst []byte, val float32, fmt byte, prec int) []byte {
+	type F = float32
+	var b uint64
+	var expBits, mantBits, bias int // parameterized constants
+	switch 8 * unsafe.Sizeof(val) {
 	case 32:
-		bits = uint64(float32bits(float32(val)))
-		flt = &float32info
+		b = uint64(float32bits(float32(val)))
+		expBits = float32ExpBits
+		mantBits = float32MantBits
+		bias = float32Bias
 	case 64:
-		bits = float64bits(val)
-		flt = &float64info
-	default:
-		panic("strconv: illegal AppendFloat/FormatFloat bitSize")
-	}
-
-	neg := bits>>(flt.expbits+flt.mantbits) != 0
-	exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
-	mant := bits & (uint64(1)<<flt.mantbits - 1)
-	denorm := false
-
-	switch exp {
-	case 1<<flt.expbits - 1:
-		// Inf, NaN
-		var s string
-		switch {
-		case mant != 0:
-			s = "NaN"
-		case neg:
-			s = "-Inf"
-		default:
-			s = "+Inf"
+		b = float64bits(float64(val))
+		expBits = float64ExpBits
+		mantBits = float64MantBits
+		bias = float64Bias
+	}
+
+	neg := b>>(expBits+mantBits) != 0
+	exp := int(b>>mantBits) & (1<<expBits - 1)
+	mant := b & (1<<mantBits - 1)
+	if exp == 1<<expBits-1 {
+		if mant != 0 {
+			return append(dst, "NaN"...)
 		}
-		return append(dst, s...)
-
-	case 0:
-		// denormalized
+		if neg {
+			return append(dst, "-Inf"...)
+		}
+		return append(dst, "+Inf"...)
+	}
+	if exp == 0 {
 		exp++
-		denorm = true
-
-	default:
-		// add implicit top bit
-		mant |= uint64(1) << flt.mantbits
+	} else {
+		mant |= 1 << mantBits
 	}
-	exp += flt.bias
+	exp += bias
 
 	// Pick off easy binary, hex formats.
 	if fmt == 'b' {
-		return fmtB(dst, neg, mant, exp, flt)
+		return fmtB(dst, neg, mant, exp-mantBits)
 	}
 	if fmt == 'x' || fmt == 'X' {
-		return fmtX(dst, prec, fmt, neg, mant, exp, flt)
+		return fmtX(dst, prec, fmt, neg, mant, exp, mantBits)
 	}
 
-	if !optimize {
-		return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
+	// Pick off zero.
+	if mant == 0 {
+		return fmtEFG(dst, neg, nil, 0, 0, prec, fmt, prec < 0)
 	}
 
 	// Negative precision means "only as much as needed to be exact."
-	shortest := prec < 0
-	var digs decimalSlice
-	if mant == 0 {
-		return formatDigits(dst, shortest, neg, digs, prec, fmt)
-	}
-	if shortest {
-		// Use the Dragonbox algorithm.
+	if prec < 0 {
+		// Use fast unrounded scaling.
 		var buf [32]byte
-		digs.d = buf[:]
-		dboxFtoa(&digs, mant, exp-int(flt.mantbits), denorm, bitSize)
+		s := 64 - bits.Len64(mant)
+		m := mant << s
+		e := exp - s
+		d, p := shortFloat[F](m, e-mantBits)
+		dp, nd := setDigits(buf[:], d, p, numDigits(d))
 		// Precision for shortest representation mode.
 		switch fmt {
 		case 'e', 'E':
-			prec = max(digs.nd-1, 0)
+			prec = max(nd-1, 0)
 		case 'f':
-			prec = max(digs.nd-digs.dp, 0)
+			prec = max(nd-dp, 0)
 		case 'g', 'G':
-			prec = digs.nd
+			prec = nd
 		}
-		return formatDigits(dst, shortest, neg, digs, prec, fmt)
+		return fmtEFG(dst, neg, buf[:], dp, nd, prec, fmt, true)
 	}
 
-	// Fixed number of digits.
-	digits := prec
-	switch fmt {
-	case 'f':
-		// %f precision specifies digits after the decimal point.
-		// Estimate an upper bound on the total number of digits needed.
-		// ftoaFixed will shorten as needed according to prec.
-		if exp >= 0 {
-			digits = 1 + mulLog10_2(1+exp) + prec
-		} else {
-			digits = 1 + prec - mulLog10_2(-exp)
+	if optimize {
+		// Fixed number of digits.
+		digits := prec
+		switch fmt {
+		case 'f':
+			// %f precision specifies digits after the decimal point.
+			// Estimate an upper bound on the total number of digits needed.
+			// ftoaFixed will shorten as needed according to prec.
+			if exp >= 0 {
+				digits = 1 + log10Pow2(1+exp) + prec
+			} else {
+				digits = 1 + prec - log10Pow2(-exp)
+			}
+		case 'e', 'E':
+			digits++
+		case 'g', 'G':
+			if prec == 0 {
+				prec = 1
+			}
+			digits = prec
+		default:
+			// Invalid mode.
+			digits = 1
+		}
+		if digits <= 18 {
+			// digits <= 0 happens for %f on very small numbers
+			// and means that we're guaranteed to print all zeros.
+			var buf [24]byte
+			var dp, nd int
+			if digits > 0 {
+				s := 64 - bits.Len64(mant)
+				m := mant << s
+				e := exp - s
+				d, p := fixedWidthFloat(m, e-mantBits, digits, prec, fmt)
+				if d != 0 {
+					dp, nd = setDigits(buf[:], d, p, numDigits(d))
+				}
+			}
+			return fmtEFG(dst, neg, buf[:], dp, nd, prec, fmt, false)
 		}
+	}
+
+	// Slow bignum case. Only for non-shortest results.
+	d := new(decimal)
+	d.Assign(mant)
+	d.Shift(exp - mantBits)
+	switch fmt {
 	case 'e', 'E':
-		digits++
+		d.Round(prec + 1)
+	case 'f':
+		d.Round(d.dp + prec)
 	case 'g', 'G':
 		if prec == 0 {
 			prec = 1
 		}
-		digits = prec
-	default:
-		// Invalid mode.
-		digits = 1
+		d.Round(prec)
 	}
-	if digits <= 18 {
-		// digits <= 0 happens for %f on very small numbers
-		// and means that we're guaranteed to print all zeros.
-		if digits > 0 {
-			var buf [24]byte
-			digs.d = buf[:]
-			fixedFtoa(&digs, mant, exp-int(flt.mantbits), digits, prec, fmt)
+	return fmtEFG(dst, neg, d.d[:], d.dp, d.nd, prec, fmt, false)
+}
+
+func ftoa64(dst []byte, val float64, fmt byte, prec int) []byte {
+	type F = float64
+	var b uint64
+	var expBits, mantBits, bias int // parameterized constants
+	switch 8 * unsafe.Sizeof(val) {
+	case 32:
+		b = uint64(float32bits(float32(val)))
+		expBits = float32ExpBits
+		mantBits = float32MantBits
+		bias = float32Bias
+	case 64:
+		b = float64bits(float64(val))
+		expBits = float64ExpBits
+		mantBits = float64MantBits
+		bias = float64Bias
+	}
+
+	neg := b>>(expBits+mantBits) != 0
+	exp := int(b>>mantBits) & (1<<expBits - 1)
+	mant := b & (1<<mantBits - 1)
+	if exp == 1<<expBits-1 {
+		if mant != 0 {
+			return append(dst, "NaN"...)
+		}
+		if neg {
+			return append(dst, "-Inf"...)
 		}
-		return formatDigits(dst, false, neg, digs, prec, fmt)
+		return append(dst, "+Inf"...)
+	}
+	if exp == 0 {
+		exp++
+	} else {
+		mant |= 1 << mantBits
 	}
+	exp += bias
 
-	return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
-}
+	// Pick off easy binary, hex formats.
+	if fmt == 'b' {
+		return fmtB(dst, neg, mant, exp-mantBits)
+	}
+	if fmt == 'x' || fmt == 'X' {
+		return fmtX(dst, prec, fmt, neg, mant, exp, mantBits)
+	}
 
-// bigFtoa uses multiprecision computations to format a float.
-func bigFtoa(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
-	d := new(decimal)
-	d.Assign(mant)
-	d.Shift(exp - int(flt.mantbits))
-	var digs decimalSlice
-	shortest := prec < 0
-	if shortest {
-		roundShortest(d, mant, exp, flt)
-		digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
+	// Pick off zero.
+	if mant == 0 {
+		return fmtEFG(dst, neg, nil, 0, 0, prec, fmt, prec < 0)
+	}
+
+	// Negative precision means "only as much as needed to be exact."
+	if prec < 0 {
+		// Use fast unrounded scaling.
+		var buf [32]byte
+		s := 64 - bits.Len64(mant)
+		m := mant << s
+		e := exp - s
+		d, p := shortFloat[F](m, e-mantBits)
+		dp, nd := setDigits(buf[:], d, p, numDigits(d))
 		// Precision for shortest representation mode.
 		switch fmt {
 		case 'e', 'E':
-			prec = digs.nd - 1
+			prec = max(nd-1, 0)
 		case 'f':
-			prec = max(digs.nd-digs.dp, 0)
+			prec = max(nd-dp, 0)
 		case 'g', 'G':
-			prec = digs.nd
+			prec = nd
 		}
-	} else {
-		// Round appropriately.
+		return fmtEFG(dst, neg, buf[:], dp, nd, prec, fmt, true)
+	}
+
+	if optimize {
+		// Fixed number of digits.
+		digits := prec
 		switch fmt {
-		case 'e', 'E':
-			d.Round(prec + 1)
 		case 'f':
-			d.Round(d.dp + prec)
+			// %f precision specifies digits after the decimal point.
+			// Estimate an upper bound on the total number of digits needed.
+			// ftoaFixed will shorten as needed according to prec.
+			if exp >= 0 {
+				digits = 1 + log10Pow2(1+exp) + prec
+			} else {
+				digits = 1 + prec - log10Pow2(-exp)
+			}
+		case 'e', 'E':
+			digits++
 		case 'g', 'G':
 			if prec == 0 {
 				prec = 1
 			}
-			d.Round(prec)
+			digits = prec
+		default:
+			// Invalid mode.
+			digits = 1
+		}
+		if digits <= 18 {
+			// digits <= 0 happens for %f on very small numbers
+			// and means that we're guaranteed to print all zeros.
+			var buf [24]byte
+			var dp, nd int
+			if digits > 0 {
+				s := 64 - bits.Len64(mant)
+				m := mant << s
+				e := exp - s
+				d, p := fixedWidthFloat(m, e-mantBits, digits, prec, fmt)
+				if d != 0 {
+					dp, nd = setDigits(buf[:], d, p, numDigits(d))
+				}
+			}
+			return fmtEFG(dst, neg, buf[:], dp, nd, prec, fmt, false)
 		}
-		digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
 	}
-	return formatDigits(dst, shortest, neg, digs, prec, fmt)
-}
 
-func formatDigits(dst []byte, shortest bool, neg bool, digs decimalSlice, prec int, fmt byte) []byte {
+	// Slow bignum case. Only for non-shortest results.
+	d := new(decimal)
+	d.Assign(mant)
+	d.Shift(exp - mantBits)
 	switch fmt {
 	case 'e', 'E':
-		return fmtE(dst, neg, digs, prec, fmt)
+		d.Round(prec + 1)
 	case 'f':
-		return fmtF(dst, neg, digs, prec)
+		d.Round(d.dp + prec)
 	case 'g', 'G':
+		if prec == 0 {
+			prec = 1
+		}
+		d.Round(prec)
+	}
+	return fmtEFG(dst, neg, d.d[:], d.dp, d.nd, prec, fmt, false)
+}
+
+func fmtEFG(dst []byte, neg bool, s []byte, dp, nd, prec int, fmt byte, shortest bool) []byte {
+	if fmt == 'g' || fmt == 'G' {
 		// trailing fractional zeros in 'e' form will be trimmed.
 		eprec := prec
-		if eprec > digs.nd && digs.nd >= digs.dp {
-			eprec = digs.nd
+		if eprec > nd && nd >= dp {
+			eprec = nd
 		}
 		// %e is used if the exponent from the conversion
 		// is less than -4 or greater than or equal to the precision.
@@ -240,286 +357,141 @@ func formatDigits(dst []byte, shortest bool, neg bool, digs decimalSlice, prec i
 		if shortest {
 			eprec = 6
 		}
-		exp := digs.dp - 1
+		exp := dp - 1
 		if exp < -4 || exp >= eprec {
-			if prec > digs.nd {
-				prec = digs.nd
+			if prec > nd {
+				prec = nd
 			}
-			return fmtE(dst, neg, digs, prec-1, fmt+'e'-'g')
-		}
-		if prec > digs.dp {
-			prec = digs.nd
+			prec--
+			fmt = fmt + 'e' - 'g'
+		} else {
+			if prec > dp {
+				prec = nd
+			}
+			prec = max(prec-dp, 0)
+			fmt = 'f'
 		}
-		return fmtF(dst, neg, digs, max(prec-digs.dp, 0))
 	}
 
-	// unknown format
-	return append(dst, '%', fmt)
-}
+	switch fmt {
+	case 'e', 'E': // %e: -d.ddddde±dd
+		// sign
+		if neg {
+			dst = append(dst, '-')
+		}
 
-// roundShortest rounds d (= mant * 2^exp) to the shortest number of digits
-// that will let the original floating point value be precisely reconstructed.
-func roundShortest(d *decimal, mant uint64, exp int, flt *floatInfo) {
-	// If mantissa is zero, the number is zero; stop now.
-	if mant == 0 {
-		d.nd = 0
-		return
-	}
-
-	// Compute upper and lower such that any decimal number
-	// between upper and lower (possibly inclusive)
-	// will round to the original floating point number.
-
-	// We may see at once that the number is already shortest.
-	//
-	// Suppose d is not denormal, so that 2^exp <= d < 10^dp.
-	// The closest shorter number is at least 10^(dp-nd) away.
-	// The lower/upper bounds computed below are at distance
-	// at most 2^(exp-mantbits).
-	//
-	// So the number is already shortest if 10^(dp-nd) > 2^(exp-mantbits),
-	// or equivalently log2(10)*(dp-nd) > exp-mantbits.
-	// It is true if 332/100*(dp-nd) >= exp-mantbits (log2(10) > 3.32).
-	minexp := flt.bias + 1 // minimum possible exponent
-	if exp > minexp && 332*(d.dp-d.nd) >= 100*(exp-int(flt.mantbits)) {
-		// The number is already shortest.
-		return
-	}
-
-	// d = mant << (exp - mantbits)
-	// Next highest floating point number is mant+1 << exp-mantbits.
-	// Our upper bound is halfway between, mant*2+1 << exp-mantbits-1.
-	upper := new(decimal)
-	upper.Assign(mant*2 + 1)
-	upper.Shift(exp - int(flt.mantbits) - 1)
-
-	// d = mant << (exp - mantbits)
-	// Next lowest floating point number is mant-1 << exp-mantbits,
-	// unless mant-1 drops the significant bit and exp is not the minimum exp,
-	// in which case the next lowest is mant*2-1 << exp-mantbits-1.
-	// Either way, call it mantlo << explo-mantbits.
-	// Our lower bound is halfway between, mantlo*2+1 << explo-mantbits-1.
-	var mantlo uint64
-	var explo int
-	if mant > 1<<flt.mantbits || exp == minexp {
-		mantlo = mant - 1
-		explo = exp
-	} else {
-		mantlo = mant*2 - 1
-		explo = exp - 1
-	}
-	lower := new(decimal)
-	lower.Assign(mantlo*2 + 1)
-	lower.Shift(explo - int(flt.mantbits) - 1)
-
-	// The upper and lower bounds are possible outputs only if
-	// the original mantissa is even, so that IEEE round-to-even
-	// would round to the original mantissa and not the neighbors.
-	inclusive := mant%2 == 0
-
-	// As we walk the digits we want to know whether rounding up would fall
-	// within the upper bound. This is tracked by upperdelta:
-	//
-	// If upperdelta == 0, the digits of d and upper are the same so far.
-	//
-	// If upperdelta == 1, we saw a difference of 1 between d and upper on a
-	// previous digit and subsequently only 9s for d and 0s for upper.
-	// (Thus rounding up may fall outside the bound, if it is exclusive.)
-	//
-	// If upperdelta == 2, then the difference is greater than 1
-	// and we know that rounding up falls within the bound.
-	var upperdelta uint8
-
-	// Now we can figure out the minimum number of digits required.
-	// Walk along until d has distinguished itself from upper and lower.
-	for ui := 0; ; ui++ {
-		// lower, d, and upper may have the decimal points at different
-		// places. In this case upper is the longest, so we iterate from
-		// ui==0 and start li and mi at (possibly) -1.
-		mi := ui - upper.dp + d.dp
-		if mi >= d.nd {
-			break
+		// first digit
+		ch := byte('0')
+		if nd != 0 {
+			ch = s[0]
 		}
-		li := ui - upper.dp + lower.dp
-		l := byte('0') // lower digit
-		if li >= 0 && li < lower.nd {
-			l = lower.d[li]
+		dst = append(dst, ch)
+
+		// .moredigits
+		if prec > 0 {
+			dst = append(dst, '.')
+			i := 1
+			m := min(nd, prec+1)
+			if i < m {
+				dst = append(dst, s[i:m]...)
+				i = m
+			}
+			for range prec + 1 - i {
+				dst = append(dst, '0')
+			}
 		}
-		m := byte('0') // middle digit
-		if mi >= 0 {
-			m = d.d[mi]
+
+		// e±
+		dst = append(dst, fmt)
+		exp := dp - 1
+		if nd == 0 { // special case: 0 has exponent 0
+			exp = 0
 		}
-		u := byte('0') // upper digit
-		if ui < upper.nd {
-			u = upper.d[ui]
+		if exp < 0 {
+			ch = '-'
+			exp = -exp
+		} else {
+			ch = '+'
 		}
+		dst = append(dst, ch)
 
-		// Okay to round down (truncate) if lower has a different digit
-		// or if lower is inclusive and is exactly the result of rounding
-		// down (i.e., and we have reached the final digit of lower).
-		okdown := l != m || inclusive && li+1 == lower.nd
-
+		// dd or ddd
 		switch {
-		case upperdelta == 0 && m+1 < u:
-			// Example:
-			// m = 12345xxx
-			// u = 12347xxx
-			upperdelta = 2
-		case upperdelta == 0 && m != u:
-			// Example:
-			// m = 12345xxx
-			// u = 12346xxx
-			upperdelta = 1
-		case upperdelta == 1 && (m != '9' || u != '0'):
-			// Example:
-			// m = 1234598x
-			// u = 1234600x
-			upperdelta = 2
+		case exp < 10:
+			dst = append(dst, '0', byte(exp)+'0')
+		case exp < 100:
+			dst = append(dst, byte(exp/10)+'0', byte(exp%10)+'0')
+		default:
+			dst = append(dst, byte(exp/100)+'0', byte(exp/10)%10+'0', byte(exp%10)+'0')
 		}
-		// Okay to round up if upper has a different digit and either upper
-		// is inclusive or upper is bigger than the result of rounding up.
-		okup := upperdelta > 0 && (inclusive || upperdelta > 1 || ui+1 < upper.nd)
+		return dst
 
-		// If it's okay to do either, then round to the nearest one.
-		// If it's okay to do only one, do it.
-		switch {
-		case okdown && okup:
-			d.Round(mi + 1)
-			return
-		case okdown:
-			d.RoundDown(mi + 1)
-			return
-		case okup:
-			d.RoundUp(mi + 1)
-			return
+	case 'f': // %f: -ddddddd.ddddd
+		// sign
+		if neg {
+			dst = append(dst, '-')
 		}
-	}
-}
-
-type decimalSlice struct {
-	d      []byte
-	nd, dp int
-}
-
-// %e: -d.ddddde±dd
-func fmtE(dst []byte, neg bool, d decimalSlice, prec int, fmt byte) []byte {
-	// sign
-	if neg {
-		dst = append(dst, '-')
-	}
-
-	// first digit
-	ch := byte('0')
-	if d.nd != 0 {
-		ch = d.d[0]
-	}
-	dst = append(dst, ch)
 
-	// .moredigits
-	if prec > 0 {
-		dst = append(dst, '.')
-		i := 1
-		m := min(d.nd, prec+1)
-		if i < m {
-			dst = append(dst, d.d[i:m]...)
-			i = m
-		}
-		for ; i <= prec; i++ {
-			dst = append(dst, '0')
-		}
-	}
-
-	// e±
-	dst = append(dst, fmt)
-	exp := d.dp - 1
-	if d.nd == 0 { // special case: 0 has exponent 0
-		exp = 0
-	}
-	if exp < 0 {
-		ch = '-'
-		exp = -exp
-	} else {
-		ch = '+'
-	}
-	dst = append(dst, ch)
-
-	// dd or ddd
-	switch {
-	case exp < 10:
-		dst = append(dst, '0', byte(exp)+'0')
-	case exp < 100:
-		dst = append(dst, byte(exp/10)+'0', byte(exp%10)+'0')
-	default:
-		dst = append(dst, byte(exp/100)+'0', byte(exp/10)%10+'0', byte(exp%10)+'0')
-	}
-
-	return dst
-}
-
-// %f: -ddddddd.ddddd
-func fmtF(dst []byte, neg bool, d decimalSlice, prec int) []byte {
-	// sign
-	if neg {
-		dst = append(dst, '-')
-	}
-
-	// integer, padded with zeros as needed.
-	if d.dp > 0 {
-		m := min(d.nd, d.dp)
-		dst = append(dst, d.d[:m]...)
-		for ; m < d.dp; m++ {
+		// integer, padded with zeros as needed.
+		if dp > 0 {
+			m := min(nd, dp)
+			for _, c := range s[:m] {
+				dst = append(dst, c)
+			}
+			for range dp - m {
+				dst = append(dst, '0')
+			}
+		} else {
 			dst = append(dst, '0')
 		}
-	} else {
-		dst = append(dst, '0')
-	}
 
-	// fraction
-	if prec > 0 {
-		dst = append(dst, '.')
-		for i := 0; i < prec; i++ {
-			ch := byte('0')
-			if j := d.dp + i; 0 <= j && j < d.nd {
-				ch = d.d[j]
+		// fraction
+		if prec > 0 {
+			dst = append(dst, '.')
+			lz := min(prec, max(0, -dp)) // leading zeros
+			off := dp + lz
+			m := min(prec-lz, max(0, nd-off)) // middle digits
+			tz := max(0, prec-lz-m)           // trailing zeros
+			for range lz {
+				dst = append(dst, '0')
+			}
+			for i := range m {
+				dst = append(dst, s[off+i])
+			}
+			for range tz {
+				dst = append(dst, '0')
 			}
-			dst = append(dst, ch)
 		}
+		return dst
 	}
 
-	return dst
+	// unknown format
+	return append(dst, '%', fmt)
 }
 
 // %b: -ddddddddp±ddd
-func fmtB(dst []byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
-	// sign
+func fmtB(dst []byte, neg bool, mant uint64, exp int) []byte {
 	if neg {
 		dst = append(dst, '-')
 	}
-
-	// mantissa
 	dst = AppendUint(dst, mant, 10)
-
-	// p
 	dst = append(dst, 'p')
-
-	// ±exponent
-	exp -= int(flt.mantbits)
 	if exp >= 0 {
 		dst = append(dst, '+')
 	}
 	dst = AppendInt(dst, int64(exp), 10)
-
 	return dst
 }
 
 // %x: -0x1.yyyyyyyyp±ddd or -0x0p+0. (y is hex digit, d is decimal digit)
-func fmtX(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
+func fmtX(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp, mantBits int) []byte {
 	if mant == 0 {
 		exp = 0
 	}
 
 	// Shift digits so leading 1 (if any) is at bit 1<<60.
-	mant <<= 60 - flt.mantbits
+	// TODO: Is this the right way to handle subnormals?
+	mant <<= 60 - mantBits
 	for mant != 0 && mant&(1<<60) == 0 {
 		mant <<= 1
 		exp--