code review 7395050: cmd/6g, cmd/8g: switch to DX for indirect call block

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"
 
 TEXT _rt0_amd64(SB),7,$-8
         // copy arguments forward on an even stack
         MOVQ    0(DI), AX               // argc
         LEAQ    8(DI), BX               // argv
@@ skipping 103 matching lines @@
         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)
         MOVQ    DX, g(CX)
         MOVQ    gobuf_sp(BX), SP        // restore SP
         MOVQ    gobuf_pc(BX), BX
         JMP     BX
 
-// void gogocall(Gobuf*, void (*fn)(void))
+// void gogocall(Gobuf*, void (*fn)(void), uintptr r0)
 // restore state from Gobuf but then call fn.
 // (call fn, returning to state in Gobuf)
 TEXT runtime·gogocall(SB), 7, $0
+        MOVQ    24(SP), DX      // context
         MOVQ    16(SP), AX              // fn
         MOVQ    8(SP), BX               // gobuf
-        MOVQ    gobuf_g(BX), DX
-        get_tls(CX)
-        MOVQ    DX, g(CX)
-        MOVQ    0(DX), CX       // make sure g != nil
+        MOVQ    gobuf_g(BX), DI
+        get_tls(CX)
+        MOVQ    DI, g(CX)
+        MOVQ    0(DI), CX       // make sure g != nil
         MOVQ    gobuf_sp(BX), SP        // restore SP
         MOVQ    gobuf_pc(BX), BX
         PUSHQ   BX
         JMP     AX
         POPQ    BX      // not reached
 
 // void gogocallfn(Gobuf*, FuncVal*)
 // restore state from Gobuf but then call fn.
 // (call fn, returning to state in Gobuf)
 TEXT runtime·gogocallfn(SB), 7, $0
-        MOVQ    16(SP), AX              // fn
+        MOVQ    16(SP), DX              // fn
         MOVQ    8(SP), BX               // gobuf
-        MOVQ    gobuf_g(BX), DX
-        get_tls(CX)
-        MOVQ    DX, g(CX)
-        MOVQ    0(DX), CX       // make sure g != nil
+        MOVQ    gobuf_g(BX), AX
+        get_tls(CX)
+        MOVQ    AX, g(CX)
+        MOVQ    0(AX), CX       // make sure g != nil
         MOVQ    gobuf_sp(BX), SP        // restore SP
         MOVQ    gobuf_pc(BX), BX
         PUSHQ   BX
-        MOVQ    0(AX), BX
+        MOVQ    0(DX), BX
         JMP     BX
         POPQ    BX      // not reached
 
 // void mcall(void (*fn)(G*))
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
 TEXT runtime·mcall(SB), 7, $0
         MOVQ    fn+0(FP), DI
 ········
@@ skipping 24 matching lines @@
  */
 
 // Called during function prolog when more stack is needed.
 // Caller has already done get_tls(CX); MOVQ m(CX), BX.
 TEXT runtime·morestack(SB),7,$0
         // Cannot grow scheduler stack (m->g0).
         MOVQ    m_g0(BX), SI
         CMPQ    g(CX), SI
         JNE     2(PC)
         INT     $3
+········
+        MOVQ    DX, m_cret(BX)
 
         // Called from f.
         // Set m->morebuf to f's caller.
         MOVQ    8(SP), AX       // f's caller's PC
         MOVQ    AX, (m_morebuf+gobuf_pc)(BX)
         LEAQ    16(SP), AX      // f's caller's SP
         MOVQ    AX, (m_morebuf+gobuf_sp)(BX)
         MOVQ    AX, m_moreargp(BX)
         get_tls(CX)
         MOVQ    g(CX), SI
@@ skipping 256 matching lines @@
         MOVQ    16(SP), AX
         XCHGQ   AX, 0(BX)
         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    8(SP), DX       // fn
         MOVQ    16(SP), BX      // caller sp
         LEAQ    -8(BX), SP      // caller sp after CALL
         SUBQ    $5, (SP)        // return to CALL again
-        MOVQ    0(AX), BX
+        MOVQ    0(DX), BX
         JMP     BX      // but first run the deferred function
 
 // Dummy function to use in saved gobuf.PC,
 // to match SP pointing at a return address.
 // The gobuf.PC is unused by the contortions here
 // but setting it to return will make the traceback code work.
 TEXT return<>(SB),7,$0
         RET
 
 // asmcgocall(void(*fn)(void*), void *arg)
@@ skipping 210 matching lines @@
 TEXT runtime·stackguard(SB),7,$0
         MOVQ    SP, DX
         MOVQ    DX, sp+0(FP)
         get_tls(CX)
         MOVQ    g(CX), BX
         MOVQ    g_stackguard(BX), DX
         MOVQ    DX, guard+8(FP)
         RET
 
 GLOBL runtime·tls0(SB), $64