[dev.power64] code review 160200044: build: merge default into dev.power64

src/cmd/cc/pgen.c

 // Inferno utils/6c/sgen.c
 // http://code.google.com/p/inferno-os/source/browse/utils/6c/sgen.c
 //
 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
 //      Portions Copyright © 1997-1999 Vita Nuova Limited
 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
 //      Portions Copyright © 2004,2006 Bruce Ellis
 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
 //      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
@@ skipping 38 matching lines @@
         memset(&nod, 0, sizeof nod);
         nod.op = ONAME;
         nod.sym = sym;
         nod.class = CSTATIC;
         gins(AFUNCDATA, nodconst(funcdatakind), &nod);
         linksym(sym)->type = SRODATA;
         return sym;
 }
 
 int
-hasdotdotdot(void)
-{
-        Type *t;
-
-        for(t=thisfn->down; t!=T; t=t->down)
+hasdotdotdot(Type *t)
+{
+        for(t=t->down; t!=T; t=t->down)
                 if(t->etype == TDOT)
                         return 1;
         return 0;
 }
 
 vlong
-argsize(void)
+argsize(int doret)
 {
         Type *t;
         int32 s;
 
 //print("t=%T\n", thisfn);
-        s = align(0, thisfn->link, Aarg0, nil);
+        s = 0;
+        if(hasdotdotdot(thisfn))
+                s = align(s, thisfn->link, Aarg0, nil);
         for(t=thisfn->down; t!=T; t=t->down) {
                 switch(t->etype) {
                 case TVOID:
                         break;
                 case TDOT:
                         if((textflag & NOSPLIT) == 0)
                                 yyerror("function takes ... without textflag NOSPLIT");
                         return ArgsSizeUnknown;
                 default:
                         s = align(s, t, Aarg1, nil);
                         s = align(s, t, Aarg2, nil);
                         break;
                 }
 //print("       %d %T\n", s, t);
         }
         if(thechar == '6' || thechar == '9')
                 s = (s+7) & ~7;
         else
                 s = (s+3) & ~3;
+        if(doret && thisfn->link->etype != TVOID) {
+                s = align(s, thisfn->link, Aarg1, nil);
+                s = align(s, thisfn->link, Aarg2, nil);
+                if(thechar == '6')
+                        s = (s+7) & ~7;
+                else
+                        s = (s+3) & ~3;
+        }
         return s;
 }
 
 void
 codgen(Node *n, Node *nn)
 {
         Prog *sp;
         Node *n1, nod, nod1;
         Sym *gcargs;
         Sym *gclocals;
@@ skipping 10 matching lines @@
                 if(n1 == Z) {
                         diag(nn, "can't find function name");
                         return;
                 }
                 if(n1->op == ONAME)
                         break;
         }
         nearln = nn->lineno;
 
         p = gtext(n1->sym, stkoff);
+        p->from.sym->cfunc = 1;
         sp = p;
 
         /*
          * generate funcdata symbol for this function.
          * data is filled in at the end of codgen().
          */
-        isvarargs = hasdotdotdot();
+        isvarargs = hasdotdotdot(thisfn);
         gcargs = nil;
         if(!isvarargs)
                 gcargs = makefuncdatasym("gcargs·%d", FUNCDATA_ArgsPointerMaps);
         gclocals = makefuncdatasym("gclocals·%d", FUNCDATA_LocalsPointerMaps);
 
         /*
          * isolate first argument
          */
         if(REGARG >= 0) {
                 if(typesuv[thisfn->link->etype]) {
@@ skipping 62 matching lines @@
         lastp = sp;
         pc = spc;
         sp->link = nil;
         suppress--;
         warnreach = owarn;
 }
 
 void
 gen(Node *n)
 {
-        Node *l, nod;
+        Node *l, nod, nod1;
         Prog *sp, *spc, *spb;
         Case *cn;
         long sbc, scc;
         int snbreak, sncontin;
         int f, o, oldreach;
 
 loop:
         if(n == Z)
                 return;
         nearln = n->lineno;
@@ skipping 40 matching lines @@
                 warnreach = !suppress;
                 complex(n);
                 if(n->type == T)
                         break;
                 l = n->left;
                 if(l == Z) {
                         noretval(3);
                         gbranch(ORETURN);
                         break;
                 }
+                if(typecmplx[n->type->etype] && !hasdotdotdot(thisfn)) {
+                        regret(&nod, n, thisfn, 2);
+                        sugen(l, &nod, n->type->width);
+                        noretval(3);
+                        gbranch(ORETURN);
+                        break;
+                }
                 if(typecmplx[n->type->etype]) {
                         sugen(l, nodret, n->type->width);
                         noretval(3);
                         gbranch(ORETURN);
                         break;
                 }
-                regret(&nod, n);
+                regret(&nod1, n, thisfn, 2);
+                nod = nod1;
+                if(nod.op != OREGISTER)
+                        regalloc(&nod, n, Z);
                 cgen(l, &nod);
+                if(nod1.op != OREGISTER)
+                        gmove(&nod, &nod1);
                 regfree(&nod);
                 if(typefd[n->type->etype])
                         noretval(1);
                 else
                         noretval(2);
                 gbranch(ORETURN);
                 break;
 
         case OLABEL:
                 canreach = 1;
@@ skipping 428 matching lines @@
         Type *t;
         int32 i;
         int32 argbytes;
         int32 symoffset, argoffset;
 
         // Dump the length of the bitmap array.  This value is always one for
         // functions written in C.
         symoffset = 0;
         gextern(sym, nodconst(1), symoffset, 4);
         symoffset += 4;
-        argbytes = (argsize() + ewidth[TIND] - 1);
+        argbytes = (argsize(1) + ewidth[TIND] - 1);
         bv = bvalloc((argbytes  / ewidth[TIND]) * BitsPerPointer);
-        argoffset = align(0, fn->link, Aarg0, nil);
+        argoffset = 0;
+        if(hasdotdotdot(thisfn))
+                argoffset = align(0, fn->link, Aarg0, nil);
         if(argoffset > 0) {
                 // The C calling convention returns structs by copying them to a
                 // location pointed to by a hidden first argument.  This first
                 // argument is a pointer.
                 if(argoffset != ewidth[TIND])
                         yyerror("passbyptr arg not the right size");
                 bvset(bv, 1); // 2 = live ptr
         }
         for(t = fn->down; t != T; t = t->down) {
                 if(t->etype == TVOID)
                         continue;
                 argoffset = align(argoffset, t, Aarg1, nil);
                 walktype1(t, argoffset, bv, 1);
                 argoffset = align(argoffset, t, Aarg2, nil);
         }
         // Dump the length of the bitmap.
         gextern(sym, nodconst(bv->n), symoffset, 4);
         symoffset += 4;
         // Dump the words of the bitmap.
         for(i = 0; i < bv->n; i += 32) {
                 gextern(sym, nodconst(bv->b[i/32]), symoffset, 4);
                 symoffset += 4;
         }
         free(bv);
         // Finalize the gc symbol.
         sym->type = typ(0, T);
         sym->type->width = symoffset;
 }