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

src/cmd/5g/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 295 matching lines @@
                 regfree(&n1);
                 break;
 
         case OITAB:
                 // itable of interface value
                 igen(nl, &n1, res);
                 n1.op = OREGISTER;      // was OINDREG
                 regalloc(&n2, n->type, &n1);
                 n1.op = OINDREG;
                 n1.type = n->type;
-                n1.xoffset = 0;
+                n1.xoffset += 0;
                 gmove(&n1, &n2);
                 gmove(&n2, res);
                 regfree(&n1);
                 regfree(&n2);
                 break;
 
         case OLEN:
                 if(istype(nl->type, TMAP) || istype(nl->type, TCHAN)) {
                         // map has len in the first 32-bit word.
                         // a zero pointer means zero length
@@ skipping 15 matching lines @@
                         regfree(&n1);
                         break;
                 }
                 if(istype(nl->type, TSTRING) || isslice(nl->type)) {
                         // both slice and string have len one pointer into the struct.
                         igen(nl, &n1, res);
                         n1.op = OREGISTER;      // was OINDREG
                         regalloc(&n2, types[TUINT32], &n1);
                         n1.op = OINDREG;
                         n1.type = types[TUINT32];
-                        n1.xoffset = Array_nel;
+                        n1.xoffset += Array_nel;
                         gmove(&n1, &n2);
                         gmove(&n2, res);
                         regfree(&n1);
                         regfree(&n2);
                         break;
                 }
                 fatal("cgen: OLEN: unknown type %lT", nl->type);
                 break;
 
         case OCAP:
@@ skipping 35 matching lines @@
         case OADDR:
                 agen(nl, res);
                 break;
 
         case OCALLMETH:
         case OCALLFUNC:
                 // Release res so that it is available for cgen_call.
                 // Pick it up again after the call.
                 rg = -1;
                 if(n->ullman >= UINF) {
-                        if(res->op == OREGISTER || res->op == OINDREG) {
+                        if(res != N && (res->op == OREGISTER || res->op == OINDREG)) {
                                 rg = res->val.u.reg;
                                 reg[rg]--;
                         }
                 }
                 if(n->op == OCALLMETH)
                         cgen_callmeth(n, 0);
                 else
                         cgen_call(n, 0);
                 if(rg >= 0)
                         reg[rg]++;
@@ skipping 464 matching lines @@
  * generate:
  *      newreg = &n;
  *      res = newreg
  *
  * on exit, a has been changed to be *newreg.
  * caller must regfree(a).
  */
 void
 igen(Node *n, Node *a, Node *res)
 {
+        Node n1;
+        Prog *p1;
+        int r;
+
+        if(debug['g']) {
+                dump("\nigen-n", n);
+        }
+        switch(n->op) {
+        case ODOT:
+                igen(n->left, a, res);
+                a->xoffset += n->xoffset;
+                a->type = n->type;
+                return;
+
+        case ODOTPTR:
+                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], res);
+                        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) {
+                                regalloc(&n1, types[tptr], N);
+                                gmove(a, &n1);
+                                p1 = gins(AMOVW, &n1, &n1);
+                                p1->from.type = D_OREG;
+                                p1->from.offset = 0;
+                                regfree(&n1);
+                        }
+                }
+                a->op = OINDREG;
+                a->xoffset = n->xoffset;
+                a->type = n->type;
+                return;
+
+        case OCALLMETH:
+        case OCALLFUNC:
+        case OCALLINTER:
+                // Release res so that it is available for cgen_call.
+                // Pick it up again after the call.
+                r = -1;
+                if(n->ullman >= UINF) {
+                        if(res != N && (res->op == OREGISTER || res->op == OINDREG)) {
+                                r = res->val.u.reg;
+                                reg[r]--;
+                        }
+                }
+                switch(n->op) {
+                case OCALLMETH:
+                        cgen_callmeth(n, 0);
+                        break;
+                case OCALLFUNC:
+                        cgen_call(n, 0);
+                        break;
+                case OCALLINTER:
+                        cgen_callinter(n, N, 0);
+                        break;
+                }
+                if(r >= 0)
+                        reg[r]++;
+                regalloc(a, types[tptr], res);
+                cgen_aret(n, a);
+                a->op = OINDREG;
+                a->type = n->type;
+                return;
+        }
+
         regalloc(a, types[tptr], res);
         agen(n, a);
         a->op = OINDREG;
         a->type = n->type;
 }
 
 /*
  * generate:
  *      newreg = &n;
  *
  * caller must regfree(a).
  */
 void
 agenr(Node *n, Node *a, Node *res)
 {
-        regalloc(a, types[tptr], res);
-        agen(n, a);
+        Node n1;
+
+        igen(n, &n1, res);
+        regalloc(a, types[tptr], N);
+        agen(&n1, a);
+        regfree(&n1);
 }
 
 void
 gencmp0(Node *n, Type *t, int o, int likely, Prog *to)
 {
         Node n1, n2, n3;
         int a;
 
         regalloc(&n1, t, N);
         cgen(n, &n1);
@@ skipping 508 matching lines @@
                         p->to.type = D_OREG;
                         p->to.offset = dir;
                         p->scond |= C_PBIT;
                 }
         }
 
         regfree(&dst);
         regfree(&src);
         regfree(&tmp);
 }