cmd/compile: don't use duffzero on Plan 9

In CL 14408, the implementation of duffzero on amd64
was changed to replace the use of the MOVQ instructions
by MOVUPS.

However, it broke the build on plan9/amd64, since
Plan 9 doesn't allow floating point in note handler.

This change disables the use of duffzero on Plan 9.
We also take care to not use the MOVUPS instruction.

Fixes #14471.

Change-Id: I8277b485dfe65a68d7d8338e52a048c5d45069bf
Reviewed-on: https://go-review.googlesource.com/19890
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 84c3d5d7d49a640067bf905717efe3001ec66f1c..b9e5bfb15fc3dab843968965e608546def2a681f 100644 (file)
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -10,6 +10,9 @@ import (
        "cmd/internal/obj/x86"
 )
 
+// no floating point in note handlers on Plan 9
+var isPlan9 = obj.Getgoos() == "plan9"
+
 func defframe(ptxt *obj.Prog) {
        var n *gc.Node
 
@@ -126,7 +129,7 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32, x0 *uin
                        *ax = 1
                }
                p = appendpp(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, frame+lo)
-       } else if cnt <= int64(8*gc.Widthreg) {
+       } else if !isPlan9 && cnt <= int64(8*gc.Widthreg) {
                if *x0 == 0 {
                        p = appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
                        *x0 = 1
@@ -139,12 +142,11 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32, x0 *uin
                if cnt%16 != 0 {
                        p = appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, frame+lo+cnt-int64(16))
                }
-       } else if !gc.Nacl && (cnt <= int64(128*gc.Widthreg)) {
+       } else if !gc.Nacl && !isPlan9 && (cnt <= int64(128*gc.Widthreg)) {
                if *x0 == 0 {
                        p = appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
                        *x0 = 1
                }
-
                p = appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, frame+lo+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
                p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
                p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
@@ -563,7 +565,7 @@ func clearfat(nl *gc.Node) {
 
        w := nl.Type.Width
 
-       if w > 1024 || (gc.Nacl && w >= 64) {
+       if w > 1024 || (w >= 64 && (gc.Nacl || isPlan9)) {
                var oldn1 gc.Node
                var n1 gc.Node
                savex(x86.REG_DI, &n1, &oldn1, nil, gc.Types[gc.Tptr])
@@ -630,6 +632,22 @@ func clearfat(nl *gc.Node) {
 }
 
 func clearfat_tail(n1 *gc.Node, b int64) {
+       if b >= 16 && isPlan9 {
+               var z gc.Node
+               gc.Nodconst(&z, gc.Types[gc.TUINT64], 0)
+               q := b / 8
+               for ; q > 0; q-- {
+                       n1.Type = z.Type
+                       gins(x86.AMOVQ, &z, n1)
+                       n1.Xoffset += 8
+                       b -= 8
+               }
+               if b != 0 {
+                       n1.Xoffset -= 8 - b
+                       gins(x86.AMOVQ, &z, n1)
+               }
+               return
+       }
        if b >= 16 {
                var vec_zero gc.Node
                gc.Regalloc(&vec_zero, gc.Types[gc.TFLOAT64], nil)