code review 4253054: runtime: scheduler, cgo reorganization

src/pkg/runtime/amd64/asm.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 "amd64/asm.h"
 
 TEXT _rt0_amd64(SB),7,$-8
         // copy arguments forward on an even stack
         MOVQ    0(DI), AX               // argc
         LEAQ    8(DI), BX               // argv
@@ skipping 71 matching lines @@
         RET
 
 TEXT runtime·breakpoint(SB),7,$0
         BYTE    $0xcc
         RET
 
 /*
  *  go-routine
  */
 
-// uintptr gosave(Gobuf*)
+// void gosave(Gobuf*)
 // save state in Gobuf; setjmp
 TEXT runtime·gosave(SB), 7, $0
         MOVQ    8(SP), AX               // gobuf
         LEAQ    8(SP), BX               // caller's SP
         MOVQ    BX, gobuf_sp(AX)
         MOVQ    0(SP), BX               // caller's PC
         MOVQ    BX, gobuf_pc(AX)
         get_tls(CX)
         MOVQ    g(CX), BX
         MOVQ    BX, gobuf_g(AX)
-        MOVL    $0, AX                  // return 0
         RET
 
 // void gogo(Gobuf*, uintptr)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), 7, $0
         MOVQ    16(SP), AX              // return 2nd arg
         MOVQ    8(SP), BX               // gobuf
         MOVQ    gobuf_g(BX), DX
         MOVQ    0(DX), CX               // make sure g != nil
         get_tls(CX)
@@ skipping 244 matching lines @@
         MOVQ    16(SP), AX
         MOVQ    24(SP), CX
         LOCK
         CMPXCHGQ        CX, 0(BX)
         JZ 3(PC)
         MOVL    $0, AX
         RET
         MOVL    $1, AX
         RET
 
-
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. pop the caller
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
 TEXT runtime·jmpdefer(SB), 7, $0
         MOVQ    8(SP), AX       // fn
         MOVQ    16(SP), BX      // caller sp
         LEAQ    -8(BX), SP      // caller sp after CALL
         SUBQ    $5, (SP)        // return to CALL again
@@ skipping 11 matching lines @@
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
 TEXT runtime·asmcgocall(SB),7,$0
         MOVQ    fn+0(FP), AX
         MOVQ    arg+8(FP), BX
         MOVQ    SP, DX
 
         // Figure out if we need to switch to m->g0 stack.
         // We get called to create new OS threads too, and those
         // come in on the m->g0 stack already.
-        // TODO(rsc): Why would we not?
         get_tls(CX)
         MOVQ    m(CX), BP
         MOVQ    m_g0(BP), SI
         MOVQ    g(CX), DI
         CMPQ    SI, DI
-        JEQ     5(PC)
+        JEQ     6(PC)
         MOVQ    SP, (g_sched+gobuf_sp)(DI)
         MOVQ    $return<>(SB), (g_sched+gobuf_pc)(DI)
         MOVQ    DI, (g_sched+gobuf_g)(DI)
+        MOVQ    SI, g(CX)
         MOVQ    (g_sched+gobuf_sp)(SI), SP
 
         // Now on a scheduling stack (a pthread-created stack).
         SUBQ    $32, SP
         ANDQ    $~15, SP        // alignment for gcc ABI
         MOVQ    DI, 16(SP)      // save g
-        MOVQ    SI, g(CX)
         MOVQ    DX, 8(SP)       // save SP
         MOVQ    BX, DI          // DI = first argument in AMD64 ABI
         CALL    AX
 
         // Restore registers, g, stack pointer.
         get_tls(CX)
         MOVQ    16(SP), DI
         MOVQ    DI, g(CX)
         MOVQ    8(SP), SP
         RET
 
-// asmcgocallback(void (*fn)(void*), void *frame, uintptr framesize)
+// cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
 // See cgocall.c for more details.
-// The frame size is·
-TEXT runtime·asmcgocallback(SB),7,$24
+TEXT runtime·cgocallback(SB),7,$24
         MOVQ    fn+0(FP), AX
         MOVQ    frame+8(FP), BX
         MOVQ    framesize+16(FP), DX
 
         // Save current m->g0->sched.sp on stack and then set it to SP.
         get_tls(CX)
         MOVQ    m(CX), BP
         MOVQ    m_g0(BP), SI
         PUSHQ   (g_sched+gobuf_sp)(SI)
         MOVQ    SP, (g_sched+gobuf_sp)(SI)
 
         // Switch to m->curg stack and call runtime.cgocallback
         // with the three arguments.  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->gobuf)
         // so that we can restore it when we're done.·
         // We can restore m->curg->gobuf.sp easily, because calling
         // runtime.cgocallback leaves SP unchanged upon return.
         // To save m->curg->gobuf.pc, we push it onto the stack.
         // This has the added benefit that it looks to the traceback
-        // routine like asmcgocallback is going to return to that
-        // PC (because we defined asmcgocallback to have
+        // routine like cgocallback is going to return to that
+        // PC (because we defined cgocallback to have
         // a frame size of 24, the same amount that we use below),
         // so that the traceback will seamlessly trace back into
         // the earlier calls.
         MOVQ    m_curg(BP), SI
         MOVQ    SI, g(CX)
         MOVQ    (g_sched+gobuf_sp)(SI), DI  // prepare stack as DI
 
         // Push gobuf.pc
         MOVQ    (g_sched+gobuf_pc)(SI), BP
         SUBQ    $8, DI
         MOVQ    BP, 0(DI)
 
-        // Push arguments to cgocallback.
+        // Push arguments to cgocallbackg.
         // Frame size here must match the frame size above
         // to trick traceback routines into doing the right thing.
         SUBQ    $24, DI
         MOVQ    AX, 0(DI)
         MOVQ    BX, 8(DI)
         MOVQ    DX, 16(DI)
 ········
         // Switch stack and make the call.
         MOVQ    DI, SP
-        CALL    runtime·cgocallback(SB)
+        CALL    runtime·cgocallbackg(SB)
 
         // Restore g->gobuf (== m->curg->gobuf) from saved values.
         get_tls(CX)
         MOVQ    g(CX), SI
-        MOVQ    SP, DI
-        ADDQ    $24, DI
-        MOVQ    0(DI), BP
+        MOVQ    24(SP), BP
         MOVQ    BP, (g_sched+gobuf_pc)(SI)
-        ADDQ    $8, DI
+        LEAQ    (24+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
         POPQ    (g_sched+gobuf_sp)(SI)
@@ skipping 33 matching lines @@
         MOVQ    x+0(FP),AX              // addr of first arg
         MOVQ    x+8(FP), BX
         MOVQ    BX, -8(AX)              // set calling pc
         RET
 
 TEXT runtime·getcallersp(SB),7,$0
         MOVQ    sp+0(FP), AX
         RET
 
 GLOBL runtime·tls0(SB), $64