code review 9223046: cmd/5l, cmd/6l, cmd/8l, cmd/gc, runtime: generate and u...

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"
 
 static void allocauto(Prog* p);
-static void stackmap(Node *fn);
+static void pointermap(Node* fn);
 
 void
 compile(Node *fn)
 {
         Plist *pl;
         Node nod1, *n;
         Prog *plocals, *ptxt, *p, *p1;
         int32 lno;
         Type *t;
         Iter save;
@@ skipping 80 matching lines @@
                 case PAUTO:
                 case PPARAM:
                 case PPARAMOUT:
                         nodconst(&nod1, types[TUINTPTR], l->n->type->width);
                         p = gins(ATYPE, l->n, &nod1);
                         p->from.gotype = ngotype(l->n);
                         break;
                 }
         }
 
-        stackmap(fn);
+        pointermap(fn);
 
         genlist(curfn->enter);
 
         retpc = nil;
         if(hasdefer || curfn->exit) {
                 p1 = gjmp(nil);
                 retpc = gjmp(nil);
                 patch(p1, pc);
         }
 
@@ skipping 42 matching lines @@
         defframe(ptxt);
 
         if(0)
                 frame(0);
 
 ret:
         lineno = lno;
 }
 
 static void
 walktype1(Type *t, vlong *xoffset, Bvec *bv)

[khr, 2013/05/09 21:49:53]

This code allocates slots for the arguments.  We must already have such code
somewhere, right?  Shouldn't we be sharing that code instead of duplicating it?

[cshapiro1, 2013/05/09 22:00:39]

I am not sure I fully understand what you mean by allocating slots for
arguments.  The way I think about this code is it sets a bit in bv for each
pointer value offset in t.

I contemplated writing a call-back driven interface for this code. 
Unfortunately, there are a lot of one offs for this sort of thing and so either
way I was going to end up with one more way do walk a type.  I just discovered
an iterator type for structs which would allow at least the bottom-most case to
be eliminated.

There is certainly an opportunity for a clean-up.

 {
         vlong fieldoffset, i, o;
         Type *t1;
 
         if(t->align > 0 && (*xoffset % t->align) != 0)
                 fatal("walktype1: invalid initial alignment, %T", t);
 
         switch(t->etype) {
         case TINT8:
         case TUINT8:
@@ skipping 20 matching lines @@
         case TFUNC:
         case TCHAN:
         case TMAP:
                 if(*xoffset % widthptr != 0)
                         fatal("walktype1: invalid alignment, %T", t);
                 bvset(bv, *xoffset / widthptr);
                 *xoffset += t->width;
                 break;
 
         case TSTRING:
-                // struct { byte *str; int32 len; }
+                // struct { byte *str; intgo len; }
                 if(*xoffset % widthptr != 0)
                         fatal("walktype1: invalid alignment, %T", t);
                 bvset(bv, *xoffset / widthptr);
                 *xoffset += t->width;
                 break;
 
         case TINTER:
-                // struct { Itab* tab;  void* data; }
-                // struct { Type* type; void* data; }   // When isnilinter(t)==true
+                // struct { Itab* tab;  union { void* ptr, uintptr val } data; }
+                // or, when isnilinter(t)==true:
+                // struct { Type* type; union { void* ptr, uintptr val } data; }
                 if(*xoffset % widthptr != 0)
                         fatal("walktype1: invalid alignment, %T", t);
                 bvset(bv, *xoffset / widthptr);
                 bvset(bv, (*xoffset + widthptr) / widthptr);
                 *xoffset += t->width;
                 break;
 
         case TARRAY:
+                // The value of t->bound is -1 for slices types and >0 for
+                // for fixed array types.  All other values are invalid.
                 if(t->bound < -1)
                         fatal("walktype1: invalid bound, %T", t);
                 if(isslice(t)) {
-                        // struct { byte* array; uint32 len; uint32 cap; }
+                        // struct { byte* array; uintgo len; uintgo cap; }
                         if(*xoffset % widthptr != 0)
                                 fatal("walktype1: invalid TARRAY alignment, %T", t);
                         bvset(bv, *xoffset / widthptr);
                         *xoffset += t->width;
                 } else if(!haspointers(t->type))
                                 *xoffset += t->width;
                 else
                         for(i = 0; i < t->bound; ++i)
                                 walktype1(t->type, xoffset, bv);
                 break;
@@ skipping 12 matching lines @@
         default:
                 fatal("walktype1: unexpected type, %T", t);
         }
 }
 
 static void
 walktype(Type *type, Bvec *bv)
 {
         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);
-}
-
-static int32
-roundup(int32 x, int32 n)
-{
-        return x + (-x & (n - 1));
 }
 
 // Compute a bit vector to describes the pointer containing locations
 // in the argument list.
 static void
-stackmap(Node *fn)
-{
-        vlong thiswidth, inargwidth, outargwidth;
+pointermap(Node *fn)
+{
         Type *thistype, *inargtype, *outargtype;
         Bvec *bv;
         Prog *prog;
         int32 i;
 
         thistype = getthisx(fn->type);
-        thiswidth = (thistype == nil) ? 0 : thistype->width;
         inargtype = getinargx(fn->type);
-        inargwidth = (inargtype == nil) ? 0 : inargtype->width;
         outargtype = getoutargx(fn->type);
-        outargwidth = (outargtype == nil) ? 0 : outargtype->width;
-        if((thistype != nil) && (inargtype != nil) && (thiswidth < inargtype->align))
-                thiswidth = inargtype->align;
-        if((inargtype != nil) && (outargtype != nil) && (inargwidth < outargtype->align))
-                inargwidth = outargtype->align;
-        bv = bvalloc((thiswidth + inargwidth + outargwidth) / widthptr);
+        bv = bvalloc(fn->type->argwid / widthptr);
         if(thistype != nil)
                 walktype(thistype, bv);
         if(inargtype != nil)
                 walktype(inargtype, bv);
         if(outargtype != nil)
                 walktype(outargtype, bv);
-        if(bv->n != 0) {
+        if(bvisempty(bv)) {
                 prog = gins(ANPTRS, N, N);
                 prog->to.type = D_CONST;
-                prog->to.offset = roundup(bv->n, 32) / 32;
-        }
-        for(i = 0; i < bv->n; i += 32) {
-                prog = gins(APTRS, N, N);
-                prog->from.type = D_CONST;
-                prog->from.offset = i;
+                prog->to.offset = 0;
+        } else {
+                prog = gins(ANPTRS, N, N);
                 prog->to.type = D_CONST;
-                prog->to.offset = bv->b[i / 32];
+                prog->to.offset = bv->n;
+                for(i = 0; i < bv->n; i += 32) {
+                        prog = gins(APTRS, N, N);
+                        prog->from.type = D_CONST;
+                        prog->from.offset = i / 32;
+                        prog->to.type = D_CONST;
+                        prog->to.offset = bv->b[i / 32];
+                }
         }
         free(bv);
 }
 
 // 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)
 {
@@ skipping 77 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;
         }
 }