[dev.power64] code review 152570049: all: merge default into dev.power64

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.
 
 // "Portable" code generation.
 // Compiled separately for 5g, 6g, and 8g, so allowed to use gg.h, opt.h.
 // Must code to the intersection of the three back ends.
 
 #include        <u.h>
 #include        <libc.h>
 #include        "md5.h"
 #include        "gg.h"
 #include        "opt.h"
 #include        "../../runtime/funcdata.h"
 
 static void allocauto(Prog* p);
+static void emitptrargsmap(void);
 
 static Sym*
 makefuncdatasym(char *namefmt, int64 funcdatakind)
 {
         Node nod;
         Node *pnod;
         Sym *sym;
         static int32 nsym;
 
         snprint(namebuf, sizeof(namebuf), namefmt, nsym++);
@@ skipping 139 matching lines @@
                 newproc = sysfunc("newproc");
                 deferproc = sysfunc("deferproc");
                 deferreturn = sysfunc("deferreturn");
                 panicindex = sysfunc("panicindex");
                 panicslice = sysfunc("panicslice");
                 throwreturn = sysfunc("throwreturn");
         }
 
         lno = setlineno(fn);
 
+        curfn = fn;
+        dowidth(curfn->type);
+
         if(fn->nbody == nil) {
-                if(pure_go || strncmp(fn->nname->sym->name, "init·", 6) == 0)
+                if(pure_go || strncmp(fn->nname->sym->name, "init·", 6) == 0) {
                         yyerror("missing function body", fn);
+                        goto ret;
+                }
+                if(debug['A'])
+                        goto ret;
+                emitptrargsmap();
                 goto ret;
         }
 
         saveerrors();
 
         // set up domain for labels
         clearlabels();
 
-        curfn = fn;
-        dowidth(curfn->type);
-
         if(curfn->type->outnamed) {
                 // add clearing of the output parameters
                 t = structfirst(&save, getoutarg(curfn->type));
                 while(t != T) {
                         if(t->nname != N) {
                                 n = nod(OAS, t->nname, N);
                                 typecheck(&n, Etop);
                                 curfn->nbody = concat(list1(n), curfn->nbody);
                         }
                         t = structnext(&save);
@@ skipping 122 matching lines @@
 
         if(0)
                 frame(0);
 
         // Remove leftover instrumentation from the instruction stream.
         removevardef(ptxt);
 ret:
         lineno = lno;
 }
 
+static void
+emitptrargsmap(void)
+{
+        int nptr, nbitmap, j, off;
+        vlong xoffset;
+        Bvec *bv;
+        Sym *sym;
+········
+        sym = lookup(smprint("%s.args_stackmap", curfn->nname->sym->name));
+
+        nptr = curfn->type->argwid / widthptr;
+        bv = bvalloc(nptr*2);
+        nbitmap = 1;
+        if(curfn->type->outtuple > 0)
+                nbitmap = 2;
+        off = duint32(sym, 0, nbitmap);
+        off = duint32(sym, off, bv->n);
+        if(curfn->type->thistuple > 0) {
+                xoffset = 0;
+                twobitwalktype1(getthisx(curfn->type), &xoffset, bv);
+        }
+        if(curfn->type->intuple > 0) {
+                xoffset = 0;
+                twobitwalktype1(getinargx(curfn->type), &xoffset, bv);
+        }
+        for(j = 0; j < bv->n; j += 32)
+                off = duint32(sym, off, bv->b[j/32]);
+        if(curfn->type->outtuple > 0) {
+                xoffset = 0;
+                twobitwalktype1(getoutargx(curfn->type), &xoffset, bv);
+                for(j = 0; j < bv->n; j += 32)
+                        off = duint32(sym, off, bv->b[j/32]);
+        }
+        ggloblsym(sym, off, RODATA);
+        free(bv);
+}
+
 // Sort the list of stack variables. Autos after anything else,
 // within autos, unused after used, within used, things with
 // pointers first, zeroed things first, and then decreasing size.
 // Because autos are laid out in decreasing addresses
 // on the stack, pointers first, zeroed things first and decreasing size
 // really means, in memory, things with pointers needing zeroing at
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
 static int
 cmpstackvar(Node *a, Node *b)
@@ skipping 145 matching lines @@
         }
         if(((thechar == '5' || thechar == '9') && n->op != OREGISTER) || !n->addable || n->op == OLITERAL) {
                 regalloc(&reg, types[tptr], n);
                 cgen(n, &reg);
                 gins(ACHECKNIL, &reg, N);
                 regfree(&reg);
                 return;
         }
         gins(ACHECKNIL, n, N);
 }