code review 11551044: runtime: reclaim another word in cgocallback_gofunc

src/pkg/runtime/asm_amd64.s

 // Copyright 2009 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.
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
 
 TEXT _rt0_go(SB),7,$0
         // copy arguments forward on an even stack
         MOVQ    DI, AX          // argc
@@ skipping 545 matching lines @@
         MOVQ    frame+8(FP), AX
         MOVQ    AX, 8(SP)
         MOVQ    framesize+16(FP), AX
         MOVQ    AX, 16(SP)
         MOVQ    $runtime·cgocallback_gofunc(SB), AX
         CALL    AX
         RET
 
 // cgocallback_gofunc(FuncVal*, void *frame, uintptr framesize)
 // See cgocall.c for more details.
-TEXT runtime·cgocallback_gofunc(SB),7,$16-24
+TEXT runtime·cgocallback_gofunc(SB),7,$8-24
         // If m is nil, Go did not create the current thread.
         // Call needm to obtain one for temporary use.
         // In this case, we're running on the thread stack, so there's
         // lots of space, but the linker doesn't know. Hide the call from
         // the linker analysis by using an indirect call through AX.
         get_tls(CX)
 #ifdef GOOS_windows
         MOVL    $0, BP
         CMPQ    CX, $0
         JEQ     2(PC)
 #endif
         MOVQ    m(CX), BP
-        MOVQ    BP, 8(SP)
+        MOVQ    BP, R8 // holds oldm until end of function
         CMPQ    BP, $0
         JNE     havem
 needm:
+        MOVQ    R8, 0(SP)
         MOVQ    $runtime·needm(SB), AX
         CALL    AX
+        MOVQ    0(SP), R8
         get_tls(CX)
         MOVQ    m(CX), BP
 
 havem:
         // Now there's a valid m, and we're running on its m->g0.
         // Save current m->g0->sched.sp on stack and then set it to SP.
         // Save current sp in m->g0->sched.sp in preparation for
         // switch back to m->curg stack.
         // NOTE: unwindm knows that the saved g->sched.sp is at 0(SP).
         MOVQ    m_g0(BP), SI
         MOVQ    (g_sched+gobuf_sp)(SI), AX
         MOVQ    AX, 0(SP)
         MOVQ    SP, (g_sched+gobuf_sp)(SI)
 
         // Switch to m->curg stack and call runtime.cgocallbackg.
         // Because we are taking over the execution of m->curg
         // but *not* resuming what had been running, we need to
         // save that information (m->curg->sched) so we can restore it.
         // We can restore m->curg->sched.sp easily, because calling
         // runtime.cgocallbackg leaves SP unchanged upon return.
         // To save m->curg->sched.pc, we push it onto the stack.
         // This has the added benefit that it looks to the traceback
         // routine like cgocallbackg is going to return to that
         // PC (because the frame we allocate below has the same
         // size as cgocallback_gofunc's frame declared above)
         // so that the traceback will seamlessly trace back into
         // the earlier calls.
         //
-        // In the new goroutine, 0(SP) and 8(SP) are unused except
-        // on Windows, where they are the SEH block.
+        // In the new goroutine, 0(SP) holds the saved R8.
         MOVQ    m_curg(BP), SI
         MOVQ    SI, g(CX)
         MOVQ    (g_sched+gobuf_sp)(SI), DI  // prepare stack as DI
         MOVQ    (g_sched+gobuf_pc)(SI), BP
         MOVQ    BP, -8(DI)
-        LEAQ    -(8+16)(DI), SP
+        LEAQ    -(8+8)(DI), SP
+        MOVQ    R8, 0(SP)
         CALL    runtime·cgocallbackg(SB)
+        MOVQ    0(SP), R8
 
         // Restore g->sched (== m->curg->sched) from saved values.
         get_tls(CX)
         MOVQ    g(CX), SI
-        MOVQ    16(SP), BP
+        MOVQ    8(SP), BP
         MOVQ    BP, (g_sched+gobuf_pc)(SI)
-        LEAQ    (16+8)(SP), DI
+        LEAQ    (8+8)(SP), DI
         MOVQ    DI, (g_sched+gobuf_sp)(SI)
 
         // Switch back to m->g0's stack and restore m->g0->sched.sp.
         // (Unlike m->curg, the g0 goroutine never uses sched.pc,
         // so we do not have to restore it.)
         MOVQ    m(CX), BP
         MOVQ    m_g0(BP), SI
         MOVQ    SI, g(CX)
         MOVQ    (g_sched+gobuf_sp)(SI), SP
         MOVQ    0(SP), AX
         MOVQ    AX, (g_sched+gobuf_sp)(SI)
 ········
         // If the m on entry was nil, we called needm above to borrow an m
         // for the duration of the call. Since the call is over, return it with dropm.
-        MOVQ    8(SP), BP
-        CMPQ    BP, $0
+        CMPQ    R8, $0
         JNE 3(PC)
         MOVQ    $runtime·dropm(SB), AX
         CALL    AX
 
         // Done!
         RET
 
 // void setmg(M*, G*); set m and g. for use by needm.
 TEXT runtime·setmg(SB), 7, $0-16
         MOVQ    mm+0(FP), AX
@@ skipping 479 matching lines @@
         RET
 
 cmp_allsame:
         XORQ    AX, AX
         XORQ    CX, CX
         CMPQ    BX, DX
         SETGT   AX      // 1 if alen > blen
         SETEQ   CX      // 1 if alen == blen
         LEAQ    -1(CX)(AX*2), AX        // 1,0,-1 result
         RET