[dev.ssa] cmd/compile: Use varkill only for non-SSAable vars

For variables which get SSA'd, SSA keeps track of all the def/kill.
It is only for on-stack variables that we need them.

This reduces stack frame sizes significantly because often the
only use of a variable was a varkill, and without that last use
the variable doesn't get allocated in the frame at all.

Fixes #12602

Change-Id: I3f00a768aa5ddd8d7772f375b25f846086a3e689
Reviewed-on: https://go-review.googlesource.com/14758
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 8e0f0dcc9b891323b3f8ecdbb40eff2154348a78..6cb5c571c2e94d35dcb2f552f0d0f51ff01924bf 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -794,7 +794,9 @@ func (s *state) stmt(n *Node) {
                // We only care about liveness info at call sites, so putting the
                // varkill in the store chain is enough to keep it correctly ordered
                // with respect to call ops.
-               s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem())
+               if !canSSA(n.Left) {
+                       s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem())
+               }
 
        case OCHECKNIL:
                p := s.expr(n.Left)

diff --git a/src/cmd/internal/obj/stack.go b/src/cmd/internal/obj/stack.go
index b1630b55fcd950f006a1eed03908e55a806e5536..87698b3eeb82e148f53b82cfd919c65e69ed2411 100644 (file)
--- a/src/cmd/internal/obj/stack.go
+++ b/src/cmd/internal/obj/stack.go
@@ -41,7 +41,7 @@ const (
        STACKSYSTEM = 0
        StackSystem = STACKSYSTEM
        StackBig    = 4096
-       StackGuard  = 960*stackGuardMultiplier + StackSystem
+       StackGuard  = 640*stackGuardMultiplier + StackSystem
        StackSmall  = 128
        StackLimit  = StackGuard - StackSystem - StackSmall
 )

diff --git a/src/runtime/stack2.go b/src/runtime/stack2.go
index 02b82ebe13039bf60c6f6a0d696b63273f787ad5..59d4ef694d13cdba44493c7ae05e76f70ad3dd9e 100644 (file)
--- a/src/runtime/stack2.go
+++ b/src/runtime/stack2.go
@@ -86,7 +86,7 @@ const (
 
        // The stack guard is a pointer this many bytes above the
        // bottom of the stack.
-       _StackGuard = 960*stackGuardMultiplier + _StackSystem
+       _StackGuard = 640*stackGuardMultiplier + _StackSystem
 
        // After a stack split check the SP is allowed to be this
        // many bytes below the stack guard.  This saves an instruction

diff --git a/test/nosplit.go b/test/nosplit.go
index e7c00f578330fc5b7a63e432763a38baea50d74f..e5c2a9f30e2f708543b8c4387642fb682b1e936b 100644 (file)
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -285,12 +285,12 @@ TestCases:
                                // Instead of rewriting the test cases above, adjust
                                // the first stack frame to use up the extra bytes.
                                if i == 0 {
-                                       size += 832 - 128
+                                       size += 512 - 128
                                        // Noopt builds have a larger stackguard.
                                        // See ../cmd/dist/buildruntime.go:stackGuardMultiplier
                                        for _, s := range strings.Split(os.Getenv("GO_GCFLAGS"), " ") {
                                                if s == "-N" {
-                                                       size += 960
+                                                       size += 640
                                                }
                                        }
                                }