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

src/pkg/runtime/cgocall.c

 // 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 "runtime.h"
 #include "arch_GOARCH.h"
 #include "stack.h"
 #include "cgocall.h"
 #include "race.h"
 #include "../../cmd/ld/textflag.h"
@@ skipping 94 matching lines @@
         if(fn == 0)
                 runtime·throw("cgocall nil");
 
         if(raceenabled)
                 runtime·racereleasemerge(&cgosync);
 
         // Create an extra M for callbacks on threads not created by Go on first cgo call.
         if(runtime·needextram && runtime·cas(&runtime·needextram, 1, 0))
                 runtime·newextram();
 
-        m->ncgocall++;
+        g->m->ncgocall++;
 
         /*
          * Lock g to m to ensure we stay on the same stack if we do a
          * cgo callback. Add entry to defer stack in case of panic.
          */
         runtime·lockOSThread();
         d.fn = &endcgoV;
         d.siz = 0;
         d.link = g->defer;
         d.argp = NoArgs;
         d.special = true;
         g->defer = &d;
 ········
-        m->ncgo++;
+        g->m->ncgo++;
 
         /*
          * Announce we are entering a system call
          * so that the scheduler knows to create another
          * M to run goroutines while we are in the
          * foreign code.
          *
          * The call to asmcgocall is guaranteed not to
          * split the stack and does not allocate memory,
          * so it is safe to call while "in a system call", outside
          * the $GOMAXPROCS accounting.
          */
         runtime·entersyscall();
         runtime·asmcgocall(fn, arg);
         runtime·exitsyscall();
 
         if(g->defer != &d || d.fn != &endcgoV)
                 runtime·throw("runtime: bad defer entry in cgocallback");
         g->defer = d.link;
         endcgo();
 }
 
 static void
 endcgo(void)
 {
         runtime·unlockOSThread();
-        m->ncgo--;
-        if(m->ncgo == 0) {
+        g->m->ncgo--;
+        if(g->m->ncgo == 0) {
                 // We are going back to Go and are not in a recursive
                 // call.  Let the GC collect any memory allocated via
                 // _cgo_allocate that is no longer referenced.
-                m->cgomal = nil;
+                g->m->cgomal = nil;
         }
 
         if(raceenabled)
                 runtime·raceacquire(&cgosync);
 }
 
 // Helper functions for cgo code.
 
 void (*_cgo_malloc)(void*);
 void (*_cgo_free)(void*);
@@ skipping 31 matching lines @@
         void *arg;
         uintptr argsize;
 };
 
 // Location of callback arguments depends on stack frame layout
 // and size of stack frame of cgocallback_gofunc.
 
 // On arm, stack frame is two words and there's a saved LR between
 // SP and the stack frame and between the stack frame and the arguments.
 #ifdef GOARCH_arm
-#define CBARGS (CallbackArgs*)((byte*)m->g0->sched.sp+4*sizeof(void*))
+#define CBARGS (CallbackArgs*)((byte*)g->m->g0->sched.sp+4*sizeof(void*))
 #endif
 
 // On amd64, stack frame is one word, plus caller PC.
 #ifdef GOARCH_amd64
-#define CBARGS (CallbackArgs*)((byte*)m->g0->sched.sp+2*sizeof(void*))
+#define CBARGS (CallbackArgs*)((byte*)g->m->g0->sched.sp+2*sizeof(void*))
 #endif
 
 // Unimplemented on amd64p32
 #ifdef GOARCH_amd64p32
 #define CBARGS (CallbackArgs*)(nil)
 #endif
 
 // On 386, stack frame is three words, plus caller PC.
 #ifdef GOARCH_386
-#define CBARGS (CallbackArgs*)((byte*)m->g0->sched.sp+4*sizeof(void*))
+#define CBARGS (CallbackArgs*)((byte*)g->m->g0->sched.sp+4*sizeof(void*))
 #endif
 
 void runtime·cgocallbackg1(void);
 
 #pragma textflag NOSPLIT
 void
 runtime·cgocallbackg(void)
 {
-        if(g != m->curg) {
+        if(g != g->m->curg) {
                 runtime·prints("runtime: bad g in cgocallback");
                 runtime·exit(2);
         }
 
         runtime·exitsyscall();  // coming out of cgo call
         runtime·cgocallbackg1();
         runtime·entersyscall(); // going back to cgo call
 }
 
 void
 runtime·cgocallbackg1(void)
 {
         CallbackArgs *cb;
         Defer d;
 
-        if(m->needextram) {
-                m->needextram = 0;
+        if(g->m->needextram) {
+                g->m->needextram = 0;
                 runtime·newextram();
         }
 
         // Add entry to defer stack in case of panic.
         d.fn = &unwindmf;
         d.siz = 0;
         d.link = g->defer;
         d.argp = NoArgs;
         d.special = true;
         g->defer = &d;
@@ skipping 19 matching lines @@
 static void
 unwindm(void)
 {
         // Restore sp saved by cgocallback during
         // unwind of g's stack (see comment at top of file).
         switch(thechar){
         default:
                 runtime·throw("runtime: unwindm not implemented");
         case '8':
         case '6':
-                m->g0->sched.sp = *(uintptr*)m->g0->sched.sp;
+                g->m->g0->sched.sp = *(uintptr*)g->m->g0->sched.sp;
                 break;
         case '5':
-                m->g0->sched.sp = *(uintptr*)((byte*)m->g0->sched.sp + 4);
+                g->m->g0->sched.sp = *(uintptr*)((byte*)g->m->g0->sched.sp + 4);
                 break;
         }
 }
 
 void
 runtime·badcgocallback(void)    // called from assembly
 {
         runtime·throw("runtime: misaligned stack in cgocallback");
 }
 
 void
 runtime·cgounimpl(void) // called from (incomplete) assembly
 {
         runtime·throw("runtime: cgo not implemented");
 }
 
 // For cgo-using programs with external linking,
 // export "main" (defined in assembly) so that libc can handle basic
 // C runtime startup and call the Go program as if it were
 // the C main function.
 #pragma cgo_export_static main