code review 3733046: new cgo windows port.

src/pkg/runtime/386/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 "386/asm.h"
 
 TEXT _rt0_386(SB),7,$0
         // copy arguments forward on an even stack
         MOVL    0(SP), AX               // argc
         LEAL    4(SP), BX               // argv
         SUBL    $128, SP                // plenty of scratch
         ANDL    $~15, SP
         MOVL    AX, 120(SP)             // save argc, argv away
         MOVL    BX, 124(SP)
 
         // if there is an initcgo, call it to let it
         // initialize and to set up GS.  if not,
         // we set up GS ourselves.
         MOVL    initcgo(SB), AX
         TESTL   AX, AX
-        JZ      2(PC)
+        JZ      4(PC)
         CALL    AX
+        CMPL runtime·iswindows(SB), $0
+        JEQ ok
 
         // set up %gs
         CALL    runtime·ldt0setup(SB)
 
         // store through it, to make sure it works
         CMPL    runtime·isplan9(SB), $1
         JEQ     ok
         get_tls(BX)
         MOVL    $0x123, g(BX)
         MOVL    runtime·tls0(SB), AX
@@ skipping 115 matching lines @@
         get_tls(CX)
         MOVL    m(CX), BX
         MOVL    m_g0(BX), SI
         CMPL    g(CX), SI
         JNE     2(PC)
         INT     $3
 
         // frame size in DX
         // arg size in AX
         // Save in m.
-        MOVL    DX, m_moreframe(BX)
-        MOVL    AX, m_moreargs(BX)
+        MOVL    DX, m_moreframesize(BX)
+        MOVL    AX, m_moreargsize(BX)
 
         // Called from f.
         // Set m->morebuf to f's caller.
         MOVL    4(SP), DI       // f's caller's PC
         MOVL    DI, (m_morebuf+gobuf_pc)(BX)
         LEAL    8(SP), CX       // f's caller's SP
         MOVL    CX, (m_morebuf+gobuf_sp)(BX)
-        MOVL    CX, (m_morefp)(BX)
+        MOVL    CX, m_moreargp(BX)
         get_tls(CX)
         MOVL    g(CX), SI
         MOVL    SI, (m_morebuf+gobuf_g)(BX)
 
         // Set m->morepc to f's PC.
         MOVL    0(SP), AX
         MOVL    AX, m_morepc(BX)
 
         // Call newstack on m's scheduling stack.
         MOVL    m_g0(BX), BP
@@ skipping 27 matching lines @@
         // We set f's frame size to 1, as a hint to newstack
         // that this is a call from reflect·call.
         // If it turns out that f needs a larger frame than
         // the default stack, f's usual stack growth prolog will
         // allocate a new segment (and recopy the arguments).
         MOVL    4(SP), AX       // fn
         MOVL    8(SP), DX       // arg frame
         MOVL    12(SP), CX      // arg size
 
         MOVL    AX, m_morepc(BX)        // f's PC
-        MOVL    DX, m_morefp(BX)        // argument frame pointer
-        MOVL    CX, m_moreargs(BX)      // f's argument size
-        MOVL    $1, m_moreframe(BX)     // f's frame size
+        MOVL    DX, m_moreargp(BX)      // f's argument pointer
+        MOVL    CX, m_moreargsize(BX)   // f's argument size
+        MOVL    $1, m_moreframesize(BX) // f's frame size
 
         // Call newstack on m's scheduling stack.
         MOVL    m_g0(BX), BP
         get_tls(CX)
         MOVL    BP, g(CX)
         MOVL    (m_sched+gobuf_sp)(BX), SP
         CALL    runtime·newstack(SB)
         MOVL    $0, 0x1103      // crash if newstack returns
         RET
 
@@ skipping 179 matching lines @@
         MOVL    g(CX), AX
         CMPL    g_stackbase(AX), SP
         JHI     2(PC)
         INT     $3
         CMPL    SP, g_stackguard(AX)
         JHI     2(PC)
         INT     $3
         RET
 
 GLOBL runtime·tls0(SB), $32