code review 10136043: runtime: refactor mallocgc

src/pkg/runtime/proc.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 "malloc.h"
 #include "stack.h"
 #include "race.h"
 #include "type.h"
@@ skipping 1923 matching lines @@
         G *gp;
         P *p;
 
         old = runtime·gomaxprocs;
         if(old < 0 || old > MaxGomaxprocs || new <= 0 || new >MaxGomaxprocs)
                 runtime·throw("procresize: invalid arg");
         // initialize new P's
         for(i = 0; i < new; i++) {
                 p = runtime·allp[i];
                 if(p == nil) {
-                        p = (P*)runtime·mallocgc(sizeof(*p), 0, 0, 1);
+                        p = (P*)runtime·mallocgc(sizeof(*p), 0, FlagNoInvokeGC);
                         p->status = Pgcstop;
                         runtime·atomicstorep(&runtime·allp[i], p);
                 }
                 if(p->mcache == nil) {
                         if(old==0 && i==0)
                                 p->mcache = m->mcache;  // bootstrap
                         else
                                 p->mcache = runtime·allocmcache();
                 }
                 if(p->runq == nil) {
                         p->runqsize = 128;
-                        p->runq = (G**)runtime·mallocgc(p->runqsize*sizeof(G*), 0, 0, 1);
+                        p->runq = (G**)runtime·mallocgc(p->runqsize*sizeof(G*), 0, FlagNoInvokeGC);
                 }
         }
 
         // redistribute runnable G's evenly
         for(i = 0; i < old; i++) {
                 p = runtime·allp[i];
                 while(gp = runqget(p))
                         globrunqput(gp);
         }
         // start at 1 because current M already executes some G and will acquire allp[0] below,
@@ skipping 573 matching lines @@
 bool
 runtime·topofstack(Func *f)
 {
         return f->entry == (uintptr)runtime·goexit ||
                 f->entry == (uintptr)runtime·mstart ||
                 f->entry == (uintptr)runtime·mcall ||
                 f->entry == (uintptr)runtime·morestack ||
                 f->entry == (uintptr)runtime·lessstack ||
                 f->entry == (uintptr)_rt0_go;
 }