code review 6245069: cmd/gc: contiguous loop layout

src/cmd/6g/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 48 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[TINT64], D_CX);
                 gins(APUSHQ, f, N);
                 nodconst(&con, types[TINT32], argsize(f->type));
                 gins(APUSHQ, &con, N);
                 if(proc == 1)
                         ginscall(newproc, 0);
                 else {
                         if(!hasdefer)
                                 fatal("hasdefer=0 but has defer");
                         ginscall(deferproc, 0);
                 }
                 gins(APOPQ, N, &reg);
                 gins(APOPQ, N, &reg);
                 if(proc == 2) {
                         nodreg(&reg, types[TINT64], D_AX);
                         gins(ATESTQ, &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 398 matching lines @@
                 ax.type = t;
                 n3.type = t;
                 gmove(&ax1, &ax);
                 gmove(&n31, &n3);
         }
 
         p3 = P;
         if(check) {
                 nodconst(&n4, t, -1);
                 gins(optoas(OCMP, t), &n3, &n4);
-                p1 = gbranch(optoas(ONE, t), T);
-                expecttaken(p1, 1);
+                p1 = gbranch(optoas(ONE, t), T, +1);
                 nodconst(&n4, t, -1LL<<(t->width*8-1));
                 if(t->width == 8) {
                         n5 = n4;
                         regalloc(&n4, t, N);
                         gins(AMOVQ, &n5, &n4);
                 }
                 gins(optoas(OCMP, t), &ax, &n4);
-                p2 = gbranch(optoas(ONE, t), T);
-                expecttaken(p2, 1);
+                p2 = gbranch(optoas(ONE, t), T, +1);
                 if(op == ODIV)
                         gmove(&n4, res);
                 if(t->width == 8)
                         regfree(&n4);
                 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);
         }
         savex(D_DX, &dx, &olddx, res, t);
         if(!issigned[t->etype]) {
                 nodconst(&n4, t, 0);
                 gmove(&n4, &dx);
         } else
                 gins(optoas(OEXTEND, t), N, N);
         gins(a, &n3, N);
@@ skipping 397 matching lines @@
                 cgen(nr, &n1);
                 gmove(&n1, &n3);
                 cgen(nl, &n2);
         }
         regfree(&n3);
 
         // test and fix up large shifts
         if(!bounded) {
                 nodconst(&n3, tcount, nl->type->width*8);
                 gins(optoas(OCMP, tcount), &n1, &n3);
-                p1 = gbranch(optoas(OLT, tcount), T);
-                expecttaken(p1, 1);
+                p1 = gbranch(optoas(OLT, tcount), T, +1);
                 if(op == ORSH && issigned[nl->type->etype]) {
                         nodconst(&n3, types[TUINT32], nl->type->width*8-1);
                         gins(a, &n3, &n2);
                 } else {
                         nodconst(&n3, nl->type, 0);
                         gmove(&n3, &n2);
                 }
                 patch(p1, pc);
         }
 
@@ skipping 194 matching lines @@
                 } else if(nr->type->width != t->width && nr->op != OLITERAL) {
                         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 244 matching lines @@
         }
 
         if(!sleasy(res)) {
                 cgen(&nres, res);
         }
         return 1;
 
 no:
         return 0;
 }