code review 6621061: cmd/5g, cmd/6g, cmd/8g: fix out of registers.

src/cmd/6g/cgen.c

 // Copyright 2009 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"
 
 /*
  * generate:
@@ skipping 587 matching lines @@
                 w = n->type->width;
                 // Generate the non-addressable child first.
                 if(nr->addable)
                         goto irad;
                 if(nl->addable) {
                         if(!isconst(nr, CTINT)) {
                                 regalloc(&n1, nr->type, N);
                                 cgen(nr, &n1);
                         }
                         if(!isconst(nl, CTSTR)) {
-                                regalloc(&n3, types[tptr], res);
-                                if(isfixedarray(nl->type))
+                                if(isfixedarray(nl->type)) {
+                                        regalloc(&n3, types[tptr], res);
                                         agen(nl, &n3);
-                                else {
+                                } else {
                                         igen(nl, &nlen, res);
                                         nlen.type = types[tptr];
                                         nlen.xoffset += Array_array;
+                                        regalloc(&n3, types[tptr], res);
                                         gmove(&nlen, &n3);
                                         nlen.type = types[simtype[TUINT]];
                                         nlen.xoffset += Array_nel-Array_array;
                                 }
                         }
                         goto index;
                 }
                 tempname(&tmp, nr->type);
                 cgen(nr, &tmp);
                 nr = &tmp;
         irad:
                 if(!isconst(nl, CTSTR)) {
-                        regalloc(&n3, types[tptr], res);
-                        if(isfixedarray(nl->type))
+                        if(isfixedarray(nl->type)) {
+                                regalloc(&n3, types[tptr], res);
                                 agen(nl, &n3);
-                        else {
+                        } else {
                                 if(!nl->addable) {
                                         // igen will need an addressable node.
                                         tempname(&tmp2, nl->type);
                                         cgen(nl, &tmp2);
                                         nl = &tmp2;
                                 }
                                 igen(nl, &nlen, res);
                                 nlen.type = types[tptr];
                                 nlen.xoffset += Array_array;
+                                regalloc(&n3, types[tptr], res);
                                 gmove(&nlen, &n3);
                                 nlen.type = types[simtype[TUINT]];
                                 nlen.xoffset += Array_nel-Array_array;
                         }
                 }
                 if(!isconst(nr, CTINT)) {
                         regalloc(&n1, nr->type, N);
                         cgen(nr, &n1);
                 }
                 goto index;
@@ skipping 157 matching lines @@
  *      res = newreg
  *
  * on exit, a has been changed to be *newreg.
  * caller must regfree(a).
  */
 void
 igen(Node *n, Node *a, Node *res)
 {
         Type *fp;
         Iter flist;
-        Node n1, n2;
+        Node n1;
 
+        if(debug['g']) {
+                dump("\nigen-n", n);
+        }
         switch(n->op) {
         case ONAME:
                 if((n->class&PHEAP) || n->class == PPARAMREF)
                         break;
                 *a = *n;
                 return;
 
         case OINDREG:
                 // Increase the refcount of the register so that igen's caller
                 // has to call regfree.
                 if(n->val.u.reg != D_SP)
                         reg[n->val.u.reg]++;
                 *a = *n;
                 return;
 
         case ODOT:
                 igen(n->left, a, res);
                 a->xoffset += n->xoffset;
                 a->type = n->type;
                 return;
 
         case ODOTPTR:
-                regalloc(a, types[tptr], res);
-                cgen(n->left, a);
+                if(n->left->addable
+                        || n->left->op == OCALLFUNC
+                        || n->left->op == OCALLMETH
+                        || n->left->op == OCALLINTER) {
+                        // igen-able nodes.
+                        igen(n->left, &n1, res);
+                        regalloc(a, types[tptr], &n1);
+                        gmove(&n1, a);
+                        regfree(&n1);
+                } else {
+                        regalloc(a, types[tptr], &n1);

[nigeltao, 2012/10/12 07:07:36]

Was the final argument supposed to change from res to &n1? Similarly in 5g/8g.

[remyoudompheng, 2012/10/12 21:26:07]

Done.

+                        cgen(n->left, a);
+                }
                 if(n->xoffset != 0) {
                         // explicit check for nil if struct is large enough
                         // that we might derive too big a pointer.
                         if(n->left->type->type->width >= unmappedzero) {
                                 n1 = *a;
                                 n1.op = OINDREG;
                                 n1.type = types[TUINT8];
                                 n1.xoffset = 0;
                                 gins(ATESTB, nodintconst(0), &n1);
                         }
@@ skipping 18 matching lines @@
                         break;
                 }
                 fp = structfirst(&flist, getoutarg(n->left->type));
                 memset(a, 0, sizeof *a);
                 a->op = OINDREG;
                 a->val.u.reg = D_SP;
                 a->addable = 1;
                 a->xoffset = fp->width;
                 a->type = n->type;
                 return;
-        
+
         case OINDEX:
                 // Index of fixed-size array by constant can
                 // put the offset in the addressing.
                 // Could do the same for slice except that we need
                 // to use the real index for the bounds checking.
                 if(isfixedarray(n->left->type) ||
                    (isptr[n->left->type->etype] && isfixedarray(n->left->left->type)))
                 if(isconst(n->right, CTINT)) {
-                        nodconst(&n1, types[TINT64], 0);
-                        n2 = *n;
-                        n2.right = &n1;
+                        // Compute &a.
+                        if(!isptr[n->left->type->etype])
+                                igen(n->left, a, res);
+                        else {
+                                igen(n->left, &n1, res);
+                                regalloc(a, types[tptr], res);
+                                gmove(&n1, a);
+                                regfree(&n1);
+                                a->op = OINDREG;
+                        }
 
-                        regalloc(a, types[tptr], res);
-                        agen(&n2, a);
-                        a->op = OINDREG;
-                        a->xoffset = mpgetfix(n->right->val.u.xval)*n->type->width;
+                        // Compute &a[i] as &a + i*width.
                         a->type = n->type;
+                        a->xoffset += mpgetfix(n->right->val.u.xval)*n->type->width;
                         return;
                 }
-························
         }
 
         regalloc(a, types[tptr], res);
         agen(n, a);
         a->op = OINDREG;
         a->type = n->type;
 }
 
 /*
  * generate:
@@ skipping 575 matching lines @@
                 regfree(&nodl);
         return 0;
 
 yes:
         if(freer)
                 regfree(&nodr);
         if(freel)
                 regfree(&nodl);
         return 1;
 }