code review 6245069: cmd/gc: contiguous loop layout

src/cmd/8g/ggen.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.
 
 #undef  EXTERN
 #define EXTERN
 #include <u.h>
 #include <libc.h>
 #include "gg.h"
 #include "opt.h"
@@ skipping 88 matching lines @@
 {
         Prog *p;
         Node reg, con;
 
         switch(proc) {
         default:
                 fatal("ginscall: bad proc %d", proc);
                 break;
 
         case 0: // normal call
+        case -1:        // normal call but no return
                 p = gins(ACALL, N, f);
                 afunclit(&p->to);
+                if(proc == -1)
+                        gins(AUNDEF, N, N);
                 break;
 
         case 1: // call in new proc (go)
         case 2: // deferred call (defer)
                 nodreg(&reg, types[TINT32], D_CX);
                 gins(APUSHL, f, N);
                 nodconst(&con, types[TINT32], argsize(f->type));
                 gins(APUSHL, &con, N);
                 if(proc == 1)
                         ginscall(newproc, 0);
                 else
                         ginscall(deferproc, 0);
                 gins(APOPL, N, &reg);
                 gins(APOPL, N, &reg);
                 if(proc == 2) {
                         nodreg(&reg, types[TINT64], D_AX);
                         gins(ATESTL, &reg, &reg);
-                        patch(gbranch(AJNE, T), retpc);
+                        patch(gbranch(AJNE, T, -1), retpc);
                 }
                 break;
         }
 }
 
 /*
  * n is call to interface method.
  * generate res = n.
  */
 void
@@ skipping 393 matching lines @@
         if(!samereg(ax, res) && !samereg(dx, res))
                 regalloc(&n1, t, res);
         else
                 regalloc(&n1, t, N);
         gmove(&t2, &n1);
         gmove(&t1, ax);
         p3 = P;
         if(check) {
                 nodconst(&n4, t, -1);
                 gins(optoas(OCMP, t), &n1, &n4);
-                p1 = gbranch(optoas(ONE, t), T);
+                p1 = gbranch(optoas(ONE, t), T, +1);
                 nodconst(&n4, t, -1LL<<(t->width*8-1));
                 gins(optoas(OCMP, t), ax, &n4);
-                p2 = gbranch(optoas(ONE, t), T);
+                p2 = gbranch(optoas(ONE, t), T, +1);
                 if(op == ODIV)
                         gmove(&n4, res);
                 if(op == OMOD) {
                         nodconst(&n4, t, 0);
                         gmove(&n4, res);
                 }
-                p3 = gbranch(AJMP, T);
+                p3 = gbranch(AJMP, T, 0);
                 patch(p1, pc);
                 patch(p2, pc);
         }
         if(!issigned[t->etype]) {
                 nodconst(&nz, t, 0);
                 gmove(&nz, dx);
         } else
                 gins(optoas(OEXTEND, t), N, N);
         gins(optoas(op, t), &n1, N);
         regfree(&n1);
@@ skipping 135 matching lines @@
                         gmove(&lo, &n1);
                 }
         } else {
                 if(nr->type->width > 4) {
                         // delayed reg alloc
                         nodreg(&n1, types[TUINT32], D_CX);
                         regalloc(&n1, types[TUINT32], &n1);             // to hold the shift type in CX
                         split64(&nt, &lo, &hi);
                         gmove(&lo, &n1);
                         gins(optoas(OCMP, types[TUINT32]), &hi, ncon(0));
-                        p2 = gbranch(optoas(ONE, types[TUINT32]), T);
+                        p2 = gbranch(optoas(ONE, types[TUINT32]), T, +1);
                         gins(optoas(OCMP, types[TUINT32]), &n1, ncon(w));
-                        p1 = gbranch(optoas(OLT, types[TUINT32]), T);
+                        p1 = gbranch(optoas(OLT, types[TUINT32]), T, +1);
                         patch(p2, pc);
                 } else {
                         gins(optoas(OCMP, nr->type), &n1, ncon(w));
-                        p1 = gbranch(optoas(OLT, types[TUINT32]), T);
+                        p1 = gbranch(optoas(OLT, types[TUINT32]), T, +1);
                 }
                 if(op == ORSH && issigned[nl->type->etype]) {
                         gins(a, ncon(w-1), &n2);
                 } else {
                         gmove(ncon(0), &n2);
                 }
                 patch(p1, pc);
         }
         gins(a, &n1, &n2);
 
@@ skipping 163 matching lines @@
                 nl = &n1;
         } else if(nr->type->width != t->width) {
                 regalloc(&n1, t, nr);
                 gmove(nr, &n1);
                 nr = &n1;
         }
         gins(optoas(OCMP, t), nl, nr);
         if(n1.op != OXXX)
                 regfree(&n1);
         if(throwpc == nil) {
-                p1 = gbranch(optoas(op, t), T);
-                expecttaken(p1, 1);
+                p1 = gbranch(optoas(op, t), T, +1);
                 throwpc = pc;
-                ginscall(panicslice, 0);
+                ginscall(panicslice, -1);
                 patch(p1, pc);
         } else {
                 op = brcom(op);
-                p1 = gbranch(optoas(op, t), T);
-                expecttaken(p1, 0);
+                p1 = gbranch(optoas(op, t), T, -1);
                 patch(p1, throwpc);
         }
 }
 
 int
 sleasy(Node *n)
 {
         if(n->op != ONAME)
                 return 0;
         if(!n->addable)
@@ skipping 253 matching lines @@
         }
 
         if(!sleasy(res)) {
                 cgen(&nres, res);
         }
         return 1;
 
 no:
         return 0;
 }