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

src/cmd/9c/cgen.c

 // cmd/9c/cgen.c from Vita Nuova.
 //
 //      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-2008 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-2008 Lucent Technologies Inc. and others
 //      Portions Copyright © 2009 The Go Authors.  All rights reserved.
@@ skipping 27 matching lines @@
         Node nod, nod1, nod2, nod3, nod4;
         int o;
         int32 v, curs;
 
         if(debug['g']) {
                 prtree(nn, "cgen lhs");
                 prtree(n, "cgen");
         }
         if(n == Z || n->type == T)
                 return;
-        if(typesu[n->type->etype]) {
+        if(typesu[n->type->etype] && (n->op != OFUNC || nn != Z)) {
                 sugen(n, nn, n->type->width);
                 return;
         }
         l = n->left;
         r = n->right;
         o = n->op;
         if(n->addable >= INDEXED) {
                 if(nn == Z) {
                         switch(o) {
                         default:
                                 nullwarn(Z, Z);
                                 break;
                         case OINDEX:
                                 nullwarn(l, r);
                                 break;
                         }
                         return;
                 }
                 gmove(n, nn);
                 return;
         }
         curs = cursafe;
 
         if(n->complex >= FNX)
         if(l->complex >= FNX)
         if(r != Z && r->complex >= FNX)
         switch(o) {
         default:
-                regret(&nod, r);
+                regret(&nod, r, 0, 0);
                 cgen(r, &nod);
 
                 regsalloc(&nod1, r);
                 gopcode(OAS, &nod, Z, &nod1);
 
                 regfree(&nod);
                 nod = *n;
                 nod.right = &nod1;
                 cgen(&nod, nn);
                 return;
@@ skipping 229 matching lines @@
                         break;
                 }
                 lcgen(l, nn);
                 break;
 
         case OFUNC:
                 if(l->complex >= FNX) {
                         if(l->op != OIND)
                                 diag(n, "bad function call");
 
-                        regret(&nod, l->left);
+                        regret(&nod, l->left, 0, 0);
                         cgen(l->left, &nod);
                         regsalloc(&nod1, l->left);
                         gopcode(OAS, &nod, Z, &nod1);
                         regfree(&nod);
 
                         nod = *n;
                         nod.left = &nod2;
                         nod2 = *l;
                         nod2.left = &nod1;
                         nod2.complex = 1;
                         cgen(&nod, nn);
 
                         return;
                 }
                 if(REGARG >= 0)
                         o = reg[REGARG];
                 gargs(r, &nod, &nod1);
                 gpcdata(PCDATA_ArgSize, curarg);
                 if(l->addable < INDEXED) {
                         reglcgen(&nod, l, Z);
                         gopcode(OFUNC, Z, Z, &nod);
                         regfree(&nod);
                 } else
                         gopcode(OFUNC, Z, Z, l);
                 gpcdata(PCDATA_ArgSize, -1);
                 if(REGARG>=0)
                         if(o != reg[REGARG])
                                 reg[REGARG]--;
-                if(nn != Z) {
-                        regret(&nod, n);
+                regret(&nod, n, l->type, 1); // update maxarg if nothing else
+                gpcdata(PCDATA_ArgSize, curarg);
+                gpcdata(PCDATA_ArgSize, -1);
+                if(nn != Z)
                         gopcode(OAS, &nod, Z, nn);
+                if(nod.op == OREGISTER)
                         regfree(&nod);
-                }
                 break;
 
         case OIND:
                 if(nn == Z) {
                         cgen(l, nn);
                         break;
                 }
                 regialloc(&nod, n, nn);
                 r = l;
                 while(r->op == OADD)
@@ skipping 381 matching lines @@
         case OGE:
         case OGT:
         case OHI:
         case OHS:
         case OLO:
         case OLS:
                 o = n->op;
                 if(true)
                         o = comrel[relindex(o)];
                 if(l->complex >= FNX && r->complex >= FNX) {
-                        regret(&nod, r);
+                        regret(&nod, r, 0, 0);
                         cgen(r, &nod);
                         regsalloc(&nod1, r);
                         gopcode(OAS, &nod, Z, &nod1);
                         regfree(&nod);
                         nod = *n;
                         nod.right = &nod1;
                         boolgen(&nod, true, nn);
                         break;
                 }
                 if(sconst(r)) {
@@ skipping 186 matching lines @@
                         break;
                 }
                 /* BOTCH -- functions can clobber rathole */
                 sugen(n->right, nodrat, w);
                 warn(n, "non-interruptable temporary");
                 sugen(nodrat, n->left, w);
                 sugen(nodrat, nn, w);
                 break;
 
         case OFUNC:
+                if(!hasdotdotdot(n->left->type)) {
+                        cgen(n, Z);
+                        if(nn != Z) {
+                                curarg -= n->type->width;
+                                regret(&nod1, n, n->left->type, 1);
+                                if(nn->complex >= FNX) {
+                                        regsalloc(&nod2, n);
+                                        cgen(&nod1, &nod2);
+                                        nod1 = nod2;
+                                }
+                                cgen(&nod1, nn);
+                        }
+                        break;
+                }
                 if(nn == Z) {
                         sugen(n, nodrat, w);
                         break;
                 }
                 if(nn->op != OIND) {
                         nn = new1(OADDR, nn, Z);
                         nn->type = types[TIND];
                         nn->addable = 0;
                 } else
                         nn = nn->left;
@@ skipping 147 matching lines @@
                 gopcode(OAS, &t2, Z, t);
                 t->xoffset += SZ_LONG;
         }
         if(c > 2) {
                 gopcode(OAS, &t1, Z, t);
                 t->xoffset += SZ_LONG;
         }
         regfree(&t1);
         regfree(&t2);
 }