cmd/compile: make 386 float-to-int conversions match amd64

Change-Id: Iff13b4471f94a6a91d8b159603a9338cb9c89747
Reviewed-on: https://go-review.googlesource.com/c/go/+/708295
Reviewed-by: Keith Randall <[email protected]>
Reviewed-by: Keith Randall <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: dr2chase

src/cmd/compile/internal/ssa/_gen/386.rules

@@ -88,8 +88,10 @@
 (Cvt32to32F ...) => (CVTSL2SS ...)
 (Cvt32to64F ...) => (CVTSL2SD ...)
 
-(Cvt32Fto32 ...) => (CVTTSS2SL ...)
-(Cvt64Fto32 ...) => (CVTTSD2SL ...)
+(Cvt32Fto32 <t> x) && base.ConvertHash.MatchPos(v.Pos, nil) => (XORL <t> y (SARLconst <t> [31] (ANDL <t> y:(CVTTSS2SL <t> x) (NOTL <typ.Int32> (MOVLf2i x)))))
+(Cvt64Fto32 <t> x) && base.ConvertHash.MatchPos(v.Pos, nil) => (XORL <t> y (SARLconst <t> [31] (ANDL <t> y:(CVTTSD2SL <t> x) (NOTL <typ.Int32> (MOVLf2i (CVTSD2SS <typ.Float32> x))))))
+(Cvt32Fto32 <t> x) && !base.ConvertHash.MatchPos(v.Pos, nil) => (CVTTSS2SL <t> x)
+(Cvt64Fto32 <t> x) && !base.ConvertHash.MatchPos(v.Pos, nil) => (CVTTSD2SL <t> x)
 
 (Cvt32Fto64F ...) => (CVTSS2SD ...)
 (Cvt64Fto32F ...) => (CVTSD2SS ...)

src/cmd/compile/internal/ssa/_gen/386Ops.go

@@ -342,6 +342,8 @@ func init() {
 		{name: "MOVWLSX", argLength: 1, reg: gp11, asm: "MOVWLSX"}, // sign extend arg0 from int16 to int32
 		{name: "MOVWLZX", argLength: 1, reg: gp11, asm: "MOVWLZX"}, // zero extend arg0 from int16 to int32
 
+		{name: "MOVLf2i", argLength: 1, reg: fpgp, typ: "UInt32"}, // move 32 bits from float to int reg, zero extend
+
 		{name: "MOVLconst", reg: gp01, asm: "MOVL", typ: "UInt32", aux: "Int32", rematerializeable: true}, // 32 low bits of auxint
 
 		{name: "CVTTSD2SL", argLength: 1, reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32

src/cmd/compile/internal/ssa/opGen.go

@@ -538,6 +538,13 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
 		ssagen.AddAux(&p.To, v)
+	case ssa.Op386MOVLf2i:
+		var p *obj.Prog
+		p = s.Prog(x86.AMOVL)
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = v.Args[0].Reg()
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = v.Reg()
 	case ssa.Op386ADDLconstmodify:
 		sc := v.AuxValAndOff()
 		val := sc.Val()

src/cmd/compile/internal/ssa/rewrite386.go

@@ -1407,16 +1407,6 @@ TEXT runtime·uint32tofloat64(SB),NOSPLIT,$8-12
 	FMOVDP	F0, ret+4(FP)
 	RET
 
-TEXT runtime·float64touint32(SB),NOSPLIT,$12-12
-	FMOVD	a+0(FP), F0
-	FSTCW	0(SP)
-	FLDCW	runtime·controlWord64trunc(SB)
-	FMOVVP	F0, 4(SP)
-	FLDCW	0(SP)
-	MOVL	4(SP), AX
-	MOVL	AX, ret+8(FP)
-	RET
-
 // gcWriteBarrier informs the GC about heap pointer writes.
 //
 // gcWriteBarrier returns space in a write barrier buffer which

src/cmd/compile/internal/x86/ssa.go

@@ -6,7 +6,6 @@ package runtime
 
 import "unsafe"
 
-func float64touint32(a float64) uint32
 func uint32tofloat64(a uint32) float64
 
 // stackcheck checks that SP is in range [g->stack.lo, g->stack.hi).

src/runtime/asm_386.s

@@ -40,10 +40,17 @@ func float64toint64(d float64) (y uint64) {
 }
 
 func float64touint64(d float64) (y uint64) {
-	_d2v(&y, d)
+	_d2vu(&y, d)
 	return
 }
 
+func float64touint32(a float64) uint32 {
+	if a >= 0xffffffff {
+		return 0xffffffff
+	}
+	return uint32(float64touint64(a))
+}
+
 func int64tofloat64(y int64) float64 {
 	if y < 0 {
 		return -uint64tofloat64(-uint64(y))
@@ -117,12 +124,16 @@ func _d2v(y *uint64, d float64) {
 	} else {
 		/* v = (hi||lo) << -sh */
 		sh := uint32(-sh)
-		if sh <= 11 {
+		if sh <= 10 {
 			ylo = xlo << sh
 			yhi = xhi<<sh | xlo>>(32-sh)
 		} else {
-			/* overflow */
-			yhi = uint32(d) /* causes something awful */
+			if x&sign64 != 0 {
+				*y = 0x8000000000000000
+			} else {
+				*y = 0x7fffffffffffffff
+			}
+			return
 		}
 	}
 	if x&sign64 != 0 {
@@ -136,6 +147,50 @@ func _d2v(y *uint64, d float64) {
 
 	*y = uint64(yhi)<<32 | uint64(ylo)
 }
+func _d2vu(y *uint64, d float64) {
+	x := *(*uint64)(unsafe.Pointer(&d))
+	if x&sign64 != 0 {
+		*y = 0
+		return
+	}
+
+	xhi := uint32(x>>32)&0xfffff | 0x100000
+	xlo := uint32(x)
+	sh := 1075 - int32(uint32(x>>52)&0x7ff)
+
+	var ylo, yhi uint32
+	if sh >= 0 {
+		sh := uint32(sh)
+		/* v = (hi||lo) >> sh */
+		if sh < 32 {
+			if sh == 0 {
+				ylo = xlo
+				yhi = xhi
+			} else {
+				ylo = xlo>>sh | xhi<<(32-sh)
+				yhi = xhi >> sh
+			}
+		} else {
+			if sh == 32 {
+				ylo = xhi
+			} else if sh < 64 {
+				ylo = xhi >> (sh - 32)
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh := uint32(-sh)
+		if sh <= 11 {
+			ylo = xlo << sh
+			yhi = xhi<<sh | xlo>>(32-sh)
+		} else {
+			/* overflow */
+			*y = 0xffffffffffffffff
+			return
+		}
+	}
+	*y = uint64(yhi)<<32 | uint64(ylo)
+}
 func uint64div(n, d uint64) uint64 {
 	// Check for 32 bit operands
 	if uint32(n>>32) == 0 && uint32(d>>32) == 0 {

src/runtime/stubs_386.go

@@ -4,9 +4,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !wasm && !386 && !arm && !mips
+//go:build !wasm
 
-// TODO fix this to work for wasm and 32-bit architectures.
+// TODO fix this to work for wasm
 // Doing more than this, however, expands the change.
 
 package main