code review 12328044: cmd/cc, cmd/gc, runtime: emit bitmaps for scanning locals.

src/cmd/gc/pgen.c

 // Copyright 2011 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        <u.h>
 #include        <libc.h>
 #include        "gg.h"
 #include        "opt.h"
 #include        "../../pkg/runtime/funcdata.h"
 
 static void allocauto(Prog* p);
-static int pointermap(Sym*, int, Node*);
-static void gcsymbol(Sym*, Node*);
+static void dumpgcargs(Node*, Sym*);
+static void dumpgclocals(Node*, Sym*);
 
 void
 compile(Node *fn)
 {
         Plist *pl;
-        Node nod1, *n, *gcnod;
+        Node nod1, *n, *gcargsnod, *gclocalsnod;
         Prog *ptxt, *p, *p1;
         int32 lno;
         Type *t;
         Iter save;
         vlong oldstksize;
         NodeList *l;
-        Sym *gcsym;
-        static int ngcsym;
+        Sym *gcargssym, *gclocalssym;
+        static int ngcargs, ngclocals;
 
         if(newproc == N) {
                 newproc = sysfunc("newproc");
                 deferproc = sysfunc("deferproc");
                 deferreturn = sysfunc("deferreturn");
                 panicindex = sysfunc("panicindex");
                 panicslice = sysfunc("panicslice");
                 throwreturn = sysfunc("throwreturn");
         }
 
@@ skipping 48 matching lines @@
         setlineno(curfn);
 
         nodconst(&nod1, types[TINT32], 0);
         ptxt = gins(ATEXT, isblank(curfn->nname) ? N : curfn->nname, &nod1);
         if(fn->dupok)
                 ptxt->TEXTFLAG = DUPOK;
         afunclit(&ptxt->from, curfn->nname);
 
         ginit();
 
-        snprint(namebuf, sizeof namebuf, "gc·%d", ngcsym++);
-        gcsym = lookup(namebuf);
-        gcnod = newname(gcsym);
-        gcnod->class = PEXTERN;
-
-        nodconst(&nod1, types[TINT32], FUNCDATA_GC);
-        gins(AFUNCDATA, &nod1, gcnod);
+        snprint(namebuf, sizeof namebuf, "gcargs·%d", ngcargs++);
+        gcargssym = lookup(namebuf);
+        gcargsnod = newname(gcargssym);
+        gcargsnod->class = PEXTERN;
+
+        nodconst(&nod1, types[TINT32], FUNCDATA_GCArgs);
+        gins(AFUNCDATA, &nod1, gcargsnod);
+
+        snprint(namebuf, sizeof(namebuf), "gclocals·%d", ngclocals++);
+        gclocalssym = lookup(namebuf);
+        gclocalsnod = newname(gclocalssym);
+        gclocalsnod->class = PEXTERN;
+
+        nodconst(&nod1, types[TINT32], FUNCDATA_GCLocals);
+        gins(AFUNCDATA, &nod1, gclocalsnod);
 
         for(t=curfn->paramfld; t; t=t->down)
                 gtrack(tracksym(t->type));
 
         for(l=fn->dcl; l; l=l->next) {
                 n = l->n;
                 if(n->op != ONAME) // might be OTYPE or OLITERAL
                         continue;
                 switch(n->class) {
                 case PAUTO:
@@ skipping 39 matching lines @@
 
         pc->as = ARET;  // overwrite AEND
         pc->lineno = lineno;
 
         if(!debug['N'] || debug['R'] || debug['P']) {
                 regopt(ptxt);
         }
 
         oldstksize = stksize;
         allocauto(ptxt);
-········
-        // Emit garbage collection symbol.
-        gcsymbol(gcsym, fn);
 
         if(0)
                 print("allocauto: %lld to %lld\n", oldstksize, (vlong)stksize);
 
         setlineno(curfn);
-        if((int64)stksize+maxarg > (1ULL<<31))
+        if((int64)stksize+maxarg > (1ULL<<31)) {
                 yyerror("stack frame too large (>2GB)");
+                goto ret;
+        }
 
         defframe(ptxt);
 
         if(0)
                 frame(0);
 
+        // Emit garbage collection symbols.
+        dumpgcargs(fn, gcargssym);
+        dumpgclocals(curfn, gclocalssym);
+
 ret:
         lineno = lno;
-}
-
-static void
-gcsymbol(Sym *gcsym, Node *fn)
-{
-        int off;
-
-        off = 0;
-        off = duint32(gcsym, off, stksize); // size of local block
-        off = pointermap(gcsym, off, fn); // pointer bitmap for args (must be last)
-        ggloblsym(gcsym, off, 0, 1);
 }
 
 static void
 walktype1(Type *t, vlong *xoffset, Bvec *bv)
 {
         vlong fieldoffset, i, o;
         Type *t1;
 
         if(t->align > 0 && (*xoffset % t->align) != 0)
                 fatal("walktype1: invalid initial alignment, %T", t);
@@ skipping 88 matching lines @@
 {
         vlong xoffset;
 
         // Start the walk at offset 0.  The correct offset will be
         // filled in by the first type encountered during the walk.
         xoffset = 0;
         walktype1(type, &xoffset, bv);
 }
 
 // Compute a bit vector to describes the pointer containing locations
-// in the argument list.
-static int
-pointermap(Sym *gcsym, int off, Node *fn)
+// in the in and out argument list and dump the bitvector length and
+// data to the provided symbol.
+static void
+dumpgcargs(Node *fn, Sym *sym)
 {
         Type *thistype, *inargtype, *outargtype;
         Bvec *bv;
         int32 i;
+        int off;
 
         thistype = getthisx(fn->type);
         inargtype = getinargx(fn->type);
         outargtype = getoutargx(fn->type);
         bv = bvalloc(fn->type->argwid / widthptr);
         if(thistype != nil)
                 walktype(thistype, bv);
         if(inargtype != nil)
                 walktype(inargtype, bv);
         if(outargtype != nil)
                 walktype(outargtype, bv);
-        off = duint32(gcsym, off, bv->n);
+        off = duint32(sym, 0, bv->n);
         for(i = 0; i < bv->n; i += 32)
-                off = duint32(gcsym, off, bv->b[i/32]);
+                off = duint32(sym, off, bv->b[i/32]);
         free(bv);
-        return off;
+        ggloblsym(sym, off, 0, 1);
+}
+
+// Compute a bit vector to describes the pointer containing locations
+// in local variables and dumps the bitvector length and data out to
+// the provided symbol.
+static void
+dumpgclocals(Node* fn, Sym *sym)
+{
+        Bvec *bv;
+        NodeList *ll;
+        Node *node;
+        vlong xoffset;
+        int32 i;
+        int off;
+
+        bv = bvalloc(rnd(stksize, widthptr) / widthptr);
+        for(ll = fn->dcl; ll != nil; ll = ll->next) {
+                node = ll->n;
+                if(node->class == PAUTO && node->op == ONAME) {
+                        if(haspointers(node->type)) {
+                                xoffset = node->xoffset + rnd(stksize,widthptr);
+                                walktype1(node->type, &xoffset, bv);
+                        }
+                }
+        }
+        off = duint32(sym, 0, bv->n);
+        for(i = 0; i < bv->n; i += 32) {
+                off = duint32(sym, off, bv->b[i/32]);
+        }
+        free(bv);
+        ggloblsym(sym, off, 0, 1);
 }
 
 // Sort the list of stack variables.  autos after anything else,
 // within autos, unused after used, and within used on reverse alignment.
 // non-autos sort on offset.
 static int
 cmpstackvar(Node *a, Node *b)
 {
         if (a->class != b->class)
                 return (a->class == PAUTO) ? 1 : -1;
@@ skipping 75 matching lines @@
         fixautoused(ptxt);
 
         // The debug information needs accurate offsets on the symbols.
         for(ll = curfn->dcl ;ll != nil; ll=ll->next) {
                 if (ll->n->class != PAUTO || ll->n->op != ONAME)
                         continue;
                 ll->n->xoffset += ll->n->stkdelta;
                 ll->n->stkdelta = 0;
         }
 }