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

src/pkg/runtime/mheap.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.
 
 // Page heap.
 //
 // See malloc.h for overview.
 //
 // When a MSpan is in the heap free list, state == MSpanFree
 // and heapmap(s->start) == span, heapmap(s->start+s->npages-1) == span.
@@ skipping 155 matching lines @@
 }
 
 // Allocate a new span of npage pages from the heap
 // and record its size class in the HeapMap and HeapMapCache.
 MSpan*
 runtime·MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, bool large, bool needzero)
 {
         MSpan *s;
 
         runtime·lock(h);
-        mstats.heap_alloc += m->mcache->local_cachealloc;
-        m->mcache->local_cachealloc = 0;
+        mstats.heap_alloc += g->m->mcache->local_cachealloc;
+        g->m->mcache->local_cachealloc = 0;
         s = MHeap_AllocLocked(h, npage, sizeclass);
         if(s != nil) {
                 mstats.heap_inuse += npage<<PageShift;
                 if(large) {
                         mstats.heap_objects++;
                         mstats.heap_alloc += npage<<PageShift;
                         // Swept spans are at the end of lists.
                         if(s->npages < nelem(h->free))
                                 runtime·MSpanList_InsertBack(&h->busy[s->npages], s);
                         else
@@ skipping 189 matching lines @@
         if(s == nil || p < s->start || v >= s->limit || s->state != MSpanInUse)
                 return nil;
         return s;
 }
 
 // Free the span back into the heap.
 void
 runtime·MHeap_Free(MHeap *h, MSpan *s, int32 acct)
 {
         runtime·lock(h);
-        mstats.heap_alloc += m->mcache->local_cachealloc;
-        m->mcache->local_cachealloc = 0;
+        mstats.heap_alloc += g->m->mcache->local_cachealloc;
+        g->m->mcache->local_cachealloc = 0;
         mstats.heap_inuse -= s->npages<<PageShift;
         if(acct) {
                 mstats.heap_alloc -= s->npages<<PageShift;
                 mstats.heap_objects--;
         }
         MHeap_FreeLocked(h, s);
         runtime·unlock(h);
 }
 
 static void
@@ skipping 250 matching lines @@
         Special **t, *x;
         uintptr offset;
         byte kind;
 
         span = runtime·MHeap_LookupMaybe(&runtime·mheap, p);
         if(span == nil)
                 runtime·throw("addspecial on invalid pointer");
 
         // Ensure that the span is swept.
         // GC accesses specials list w/o locks. And it's just much safer.
-        m->locks++;
+        g->m->locks++;
         runtime·MSpan_EnsureSwept(span);
 
         offset = (uintptr)p - (span->start << PageShift);
         kind = s->kind;
 
         runtime·lock(&span->specialLock);
 
         // Find splice point, check for existing record.
         t = &span->specials;
         while((x = *t) != nil) {
                 if(offset == x->offset && kind == x->kind) {
                         runtime·unlock(&span->specialLock);
-                        m->locks--;
+                        g->m->locks--;
                         return false; // already exists
                 }
                 if(offset < x->offset || (offset == x->offset && kind < x->kind))
                         break;
                 t = &x->next;
         }
         // Splice in record, fill in offset.
         s->offset = offset;
         s->next = x;
         *t = s;
         runtime·unlock(&span->specialLock);
-        m->locks--;
+        g->m->locks--;
         return true;
 }
 
 // Removes the Special record of the given kind for the object p.
 // Returns the record if the record existed, nil otherwise.
 // The caller must FixAlloc_Free the result.
 static Special*
 removespecial(void *p, byte kind)
 {
         MSpan *span;
         Special *s, **t;
         uintptr offset;
 
         span = runtime·MHeap_LookupMaybe(&runtime·mheap, p);
         if(span == nil)
                 runtime·throw("removespecial on invalid pointer");
 
         // Ensure that the span is swept.
         // GC accesses specials list w/o locks. And it's just much safer.
-        m->locks++;
+        g->m->locks++;
         runtime·MSpan_EnsureSwept(span);
 
         offset = (uintptr)p - (span->start << PageShift);
 
         runtime·lock(&span->specialLock);
         t = &span->specials;
         while((s = *t) != nil) {
                 // This function is used for finalizers only, so we don't check for
                 // "interior" specials (p must be exactly equal to s->offset).
                 if(offset == s->offset && kind == s->kind) {
                         *t = s->next;
                         runtime·unlock(&span->specialLock);
-                        m->locks--;
+                        g->m->locks--;
                         return s;
                 }
                 t = &s->next;
         }
         runtime·unlock(&span->specialLock);
-        m->locks--;
+        g->m->locks--;
         return nil;
 }
 
 // Adds a finalizer to the object p.  Returns true if it succeeded.
 bool
 runtime·addfinalizer(void *p, FuncVal *f, uintptr nret, Type *fint, PtrType *ot)
 {
         SpecialFinalizer *s;
 
         runtime·lock(&runtime·mheap.speciallock);
@@ skipping 189 matching lines @@
                 runtime·unlock(c);
         } else {
                 // Swept spans are at the end of lists.
                 if(s->npages < nelem(h->free))
                         runtime·MSpanList_InsertBack(&h->busy[s->npages], s);
                 else
                         runtime·MSpanList_InsertBack(&h->busylarge, s);
                 runtime·unlock(h);
         }
 }