code review 109050043: all: remove 'extern register M *m' from runtime

src/pkg/runtime/asm_386.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"
 #include "../../cmd/ld/textflag.h"
 
 TEXT _rt0_go(SB),NOSPLIT,$0
         // copy arguments forward on an even stack
@@ skipping 22 matching lines @@
         MOVL    CX, runtime·cpuid_ecx(SB)
         MOVL    DX, runtime·cpuid_edx(SB)
 nocpuinfo:······
 
         // if there is an _cgo_init, call it to let it
         // initialize and to set up GS.  if not,
         // we set up GS ourselves.
         MOVL    _cgo_init(SB), AX
         TESTL   AX, AX
         JZ      needtls
-        MOVL    $setmg_gcc<>(SB), BX
+        MOVL    $setg_gcc<>(SB), BX
         MOVL    BX, 4(SP)
         MOVL    BP, 0(SP)
         CALL    AX
         // update stackguard after _cgo_init
         MOVL    $runtime·g0(SB), CX
         MOVL    g_stackguard0(CX), AX
         MOVL    AX, g_stackguard(CX)
         // skip runtime·ldt0setup(SB) and tls test after _cgo_init for non-windows
         CMPL runtime·iswindows(SB), $0
         JEQ ok
@@ skipping 11 matching lines @@
         MOVL    runtime·tls0(SB), AX
         CMPL    AX, $0x123
         JEQ     ok
         MOVL    AX, 0   // abort
 ok:
         // set up m and g "registers"
         get_tls(BX)
         LEAL    runtime·g0(SB), CX
         MOVL    CX, g(BX)
         LEAL    runtime·m0(SB), AX
-        MOVL    AX, m(BX)
 
         // save m->g0 = g0
         MOVL    CX, m_g0(AX)
+        // save g0->m = m0
+        MOVL    AX, g_m(CX)
 
         CALL    runtime·emptyfunc(SB)   // fault if stack check is wrong
 
         // convention is D is always cleared
         CLD
 
         CALL    runtime·check(SB)
 
         // saved argc, argv
         MOVL    120(SP), AX
@@ skipping 82 matching lines @@
 ········
         get_tls(CX)
         MOVL    g(CX), AX       // save state in g->sched
         MOVL    0(SP), BX       // caller's PC
         MOVL    BX, (g_sched+gobuf_pc)(AX)
         LEAL    4(SP), BX       // caller's SP
         MOVL    BX, (g_sched+gobuf_sp)(AX)
         MOVL    AX, (g_sched+gobuf_g)(AX)
 
         // switch to m->g0 & its stack, call fn
-        MOVL    m(CX), BX
+        MOVL    g(CX), BX
+        MOVL    g_m(BX), BX
         MOVL    m_g0(BX), SI
         CMPL    SI, AX  // if g == m->g0 call badmcall
         JNE     3(PC)
         MOVL    $runtime·badmcall(SB), AX
         JMP     AX
         MOVL    SI, g(CX)       // g = m->g0
         MOVL    (g_sched+gobuf_sp)(SI), SP      // sp = m->g0->sched.sp
         PUSHL   AX
         CALL    DI
         POPL    AX
         MOVL    $runtime·badmcall2(SB), AX
         JMP     AX
         RET
 
 /*
  * support for morestack
  */
 
 // Called during function prolog when more stack is needed.
 //
 // The traceback routines see morestack on a g0 as being
 // the top of a stack (for example, morestack calling newstack
 // calling the scheduler calling newm calling gc), so we must
 // record an argument size. For that purpose, it has no arguments.
 TEXT runtime·morestack(SB),NOSPLIT,$0-0
         // Cannot grow scheduler stack (m->g0).
         get_tls(CX)
-        MOVL    m(CX), BX
+        MOVL    g(CX), BX
+        MOVL    g_m(BX), BX
         MOVL    m_g0(BX), SI
         CMPL    g(CX), SI
         JNE     2(PC)
         INT     $3
 
         // frame size in DI
         // arg size in AX
         // Save in m.
         MOVL    DI, m_moreframesize(BX)
         MOVL    AX, m_moreargsize(BX)
@@ skipping 31 matching lines @@
         MOVL    $0, DX
         JMP runtime·morestack(SB)
 
 // Called from panic.  Mimics morestack,
 // reuses stack growth code to create a frame
 // with the desired args running the desired function.
 //
 // func call(fn *byte, arg *byte, argsize uint32).
 TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
         get_tls(CX)
-        MOVL    m(CX), BX
+        MOVL    g(CX), BX
+        MOVL    g_m(BX), BX
 
         // Save our caller's state as the PC and SP to
         // restore when returning from f.
         MOVL    0(SP), AX       // our caller's PC
         MOVL    AX, (m_morebuf+gobuf_pc)(BX)
         LEAL    4(SP), AX       // our caller's SP
         MOVL    AX, (m_morebuf+gobuf_sp)(BX)
         MOVL    g(CX), AX
         MOVL    AX, (m_morebuf+gobuf_g)(BX)
 
@@ skipping 136 matching lines @@
 CALLFN(call536870912, 536870912)
 CALLFN(call1073741824, 1073741824)
 
 // Return point when leaving stack.
 //
 // Lessstack can appear in stack traces for the same reason
 // as morestack; in that context, it has 0 arguments.
 TEXT runtime·lessstack(SB), NOSPLIT, $0-0
         // Save return value in m->cret
         get_tls(CX)
-        MOVL    m(CX), BX
+        MOVL    g(CX), BX
+        MOVL    g_m(BX), BX
         MOVL    AX, m_cret(BX)
 
         // Call oldstack on m->g0's stack.
         MOVL    m_g0(BX), BP
         MOVL    BP, g(CX)
         MOVL    (g_sched+gobuf_sp)(BP), SP
         CALL    runtime·oldstack(SB)
         MOVL    $0, 0x1004      // crash if oldstack returns
         RET
 
@@ skipping 170 matching lines @@
 // See cgocall.c for more details.
 TEXT runtime·asmcgocall(SB),NOSPLIT,$0-8
         MOVL    fn+0(FP), AX
         MOVL    arg+4(FP), BX
         MOVL    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.
         get_tls(CX)
-        MOVL    m(CX), BP
+        MOVL    g(CX), BP
+        MOVL    g_m(BP), BP
         MOVL    m_g0(BP), SI
         MOVL    g(CX), DI
         CMPL    SI, DI
         JEQ     4(PC)
         CALL    gosave<>(SB)
         MOVL    SI, g(CX)
         MOVL    (g_sched+gobuf_sp)(SI), SP
 
         // Now on a scheduling stack (a pthread-created stack).
         SUBL    $32, SP
@@ skipping 20 matching lines @@
         MOVL    AX, 4(SP)
         MOVL    framesize+8(FP), AX
         MOVL    AX, 8(SP)
         MOVL    $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),NOSPLIT,$12-12
-        // If m is nil, Go did not create the current thread.
+        // If g 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
         CMPL    CX, $0
-        JEQ     2(PC)
+        JEQ     2(PC) // TODO
 #endif
-        MOVL    m(CX), BP
+        MOVL    g(CX), BP
+        CMPL    BP, $0
+        JEQ     needm
+        MOVL    g_m(BP), BP
         MOVL    BP, DX // saved copy of oldm
-        CMPL    BP, $0
-        JNE     havem
+        JMP     havem
 needm:
-        MOVL    DX, 0(SP)
+        MOVL    $0, 0(SP)
         MOVL    $runtime·needm(SB), AX
         CALL    AX
         MOVL    0(SP), DX
         get_tls(CX)
-        MOVL    m(CX), BP
+        MOVL    g(CX), BP
+        MOVL    g_m(BP), 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).
         MOVL    m_g0(BP), SI
         MOVL    (g_sched+gobuf_sp)(SI), AX
         MOVL    AX, 0(SP)
@@ skipping 29 matching lines @@
         get_tls(CX)
         MOVL    g(CX), SI
         MOVL    12(SP), BP
         MOVL    BP, (g_sched+gobuf_pc)(SI)
         LEAL    (12+4)(SP), DI
         MOVL    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.)
-        MOVL    m(CX), BP
+        MOVL    g(CX), BP
+        MOVL    g_m(BP), BP
         MOVL    m_g0(BP), SI
         MOVL    SI, g(CX)
         MOVL    (g_sched+gobuf_sp)(SI), SP
         MOVL    0(SP), AX
         MOVL    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.
         CMPL    DX, $0
         JNE 3(PC)
         MOVL    $runtime·dropm(SB), AX
         CALL    AX
 
         // Done!
         RET
 
-// void setmg(M*, G*); set m and g. for use by needm.
-TEXT runtime·setmg(SB), NOSPLIT, $0-8
+// void setg(G*); set g. for use by needm.
+TEXT runtime·setg(SB), NOSPLIT, $0-8
+        MOVL    gg+0(FP), BX
 #ifdef GOOS_windows
-        MOVL    mm+0(FP), AX
-        CMPL    AX, $0
+        CMPL    BX, $0
         JNE     settls
         MOVL    $0, 0x14(FS)
         RET
 settls:
+        MOVL    g_m(BX), AX
         LEAL    m_tls(AX), AX
         MOVL    AX, 0x14(FS)
 #endif
-        MOVL    mm+0(FP), AX
         get_tls(CX)
-        MOVL    mm+0(FP), AX
-        MOVL    AX, m(CX)
-        MOVL    gg+4(FP), BX
         MOVL    BX, g(CX)
         RET
 
-// void setmg_gcc(M*, G*); set m and g. for use by gcc
-TEXT setmg_gcc<>(SB), NOSPLIT, $0
+// void setg_gcc(G*); set g. for use by gcc
+TEXT setg_gcc<>(SB), NOSPLIT, $0
         get_tls(AX)
-        MOVL    mm+0(FP), DX
-        MOVL    DX, m(AX)
-        MOVL    gg+4(FP), DX
-        MOVL    DX,g (AX)
+        MOVL    gg+0(FP), DX
+        MOVL    DX, g(AX)
         RET
 
 // check that SP is in range [g->stackbase, g->stackguard)
 TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
         get_tls(CX)
         MOVL    g(CX), AX
         CMPL    g_stackbase(AX), SP
         JHI     2(PC)
         INT     $3
         CMPL    SP, g_stackguard(AX)
@@ skipping 1410 matching lines @@
 ········
         MOVL    (SI),CX
         ADDL    $4,SI
         MOVL    CX,(DI)
         ADDL    $4,DI
 ········
         RET
 
 TEXT runtime·timenow(SB), NOSPLIT, $0-0
         JMP     time·now(SB)