code review 6245069: cmd/gc: contiguous loop layout

src/cmd/8g/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.
 
 // TODO(rsc):
 //      assume CLD?
 
 #include <u.h>
 #include <libc.h>
 #include "gg.h"
@@ skipping 178 matching lines @@
         // these call bgen to get a bool value
         case OOROR:
         case OANDAND:
         case OEQ:
         case ONE:
         case OLT:
         case OLE:
         case OGE:
         case OGT:
         case ONOT:
-                p1 = gbranch(AJMP, T);
+                p1 = gbranch(AJMP, T, 0);
                 p2 = pc;
                 gmove(nodbool(1), res);
-                p3 = gbranch(AJMP, T);
+                p3 = gbranch(AJMP, T, 0);
                 patch(p1, pc);
-                bgen(n, 1, p2);
+                bgen(n, 1, 0, p2);
                 gmove(nodbool(0), res);
                 patch(p3, pc);
                 return;
 
         case OPLUS:
                 cgen(nl, res);
                 return;
 
         case OMINUS:
         case OCOM:
@@ skipping 53 matching lines @@
                         // map has len in the first 32-bit word.
                         // a zero pointer means zero length
                         tempname(&n1, types[tptr]);
                         cgen(nl, &n1);
                         regalloc(&n2, types[tptr], N);
                         gmove(&n1, &n2);
                         n1 = n2;
 
                         nodconst(&n2, types[tptr], 0);
                         gins(optoas(OCMP, types[tptr]), &n1, &n2);
-                        p1 = gbranch(optoas(OEQ, types[tptr]), T);
+                        p1 = gbranch(optoas(OEQ, types[tptr]), T, -1);
 
                         n2 = n1;
                         n2.op = OINDREG;
                         n2.type = types[TINT32];
                         gmove(&n2, &n1);
 
                         patch(p1, pc);
 
                         gmove(&n1, res);
                         regfree(&n1);
@@ skipping 13 matching lines @@
 
         case OCAP:
                 if(istype(nl->type, TCHAN)) {
                         // chan has cap in the second 32-bit word.
                         // a zero pointer means zero length
                         regalloc(&n1, types[tptr], res);
                         cgen(nl, &n1);
 
                         nodconst(&n2, types[tptr], 0);
                         gins(optoas(OCMP, types[tptr]), &n1, &n2);
-                        p1 = gbranch(optoas(OEQ, types[tptr]), T);
+                        p1 = gbranch(optoas(OEQ, types[tptr]), T, -1);
 
                         n2 = n1;
                         n2.op = OINDREG;
                         n2.xoffset = 4;
                         n2.type = types[TINT32];
                         gmove(&n2, &n1);
 
                         patch(p1, pc);
 
                         gmove(&n1, res);
@@ skipping 141 matching lines @@
         cgen(n, &tmp);
         split64(&tmp, &lo, &hi);
         gmove(&lo, res);
         if(debug['B']) {
                 splitclean();
                 return nil;
         }
         nodconst(&zero, types[TINT32], 0);
         gins(ACMPL, &hi, &zero);
         splitclean();
-        return gbranch(AJNE, T);
+        return gbranch(AJNE, T, +1);
 }
 ················
 /*
  * address gen
  *      res = &n;
  */
 void
 agen(Node *n, Node *res)
 {
         Node *nl, *nr;
@@ skipping 103 matching lines @@
                                 fatal("constant string constant index");
                         v = mpgetfix(nr->val.u.xval);
                         if(isslice(nl->type) || nl->type->etype == TSTRING) {
                                 if(!debug['B'] && !n->bounded) {
                                         n1 = n3;
                                         n1.op = OINDREG;
                                         n1.type = types[tptr];
                                         n1.xoffset = Array_nel;
                                         nodconst(&n2, types[TUINT32], v);
                                         gins(optoas(OCMP, types[TUINT32]), &n1, &n2);
-                                        p1 = gbranch(optoas(OGT, types[TUINT32]), T);
-                                        expecttaken(p1, 1);
-                                        ginscall(panicindex, 0);
+                                        p1 = gbranch(optoas(OGT, types[TUINT32]), T, +1);
+                                        ginscall(panicindex, -1);
                                         patch(p1, pc);
                                 }
 
                                 n1 = n3;
                                 n1.op = OINDREG;
                                 n1.type = types[tptr];
                                 n1.xoffset = Array_array;
                                 gmove(&n1, &n3);
                         }
 
@@ skipping 15 matching lines @@
                         if(isconst(nl, CTSTR))
                                 nodconst(&n1, types[TUINT32], nl->val.u.sval->len);
                         else if(isslice(nl->type) || nl->type->etype == TSTRING) {
                                 n1 = n3;
                                 n1.op = OINDREG;
                                 n1.type = types[tptr];
                                 n1.xoffset = Array_nel;
                         } else
                                 nodconst(&n1, types[TUINT32], nl->type->bound);
                         gins(optoas(OCMP, types[TUINT32]), &n2, &n1);
-                        p1 = gbranch(optoas(OLT, types[TUINT32]), T);
-                        expecttaken(p1, 1);
+                        p1 = gbranch(optoas(OLT, types[TUINT32]), T, +1);
                         if(p2)
                                 patch(p2, pc);
-                        ginscall(panicindex, 0);
+                        ginscall(panicindex, -1);
                         patch(p1, pc);
                 }
 ················
                 if(isconst(nl, CTSTR)) {
                         regalloc(&n3, types[tptr], res);
                         p1 = gins(ALEAL, N, &n3);
                         datastring(nl->val.u.sval->s, nl->val.u.sval->len, &p1->from);
                         p1->from.scale = 1;
                         p1->from.index = n2.val.u.reg;
                         goto indexdone;
@@ skipping 144 matching lines @@
         agen(n, &n1);
         regalloc(a, types[tptr], res);
         gmove(&n1, a);
 }
 
 /*
  * branch gen
  *      if(n == true) goto to;
  */
 void
-bgen(Node *n, int true, Prog *to)
+bgen(Node *n, int true, int likely, Prog *to)
 {
         int et, a;
         Node *nl, *nr, *r;
         Node n1, n2, tmp, t1, t2, ax;
         NodeList *ll;
         Prog *p1, *p2;
 
         if(debug['g']) {
                 dump("\nbgen", n);
         }
@@ skipping 21 matching lines @@
         switch(n->op) {
         default:
         def:
                 regalloc(&n1, n->type, N);
                 cgen(n, &n1);
                 nodconst(&n2, n->type, 0);
                 gins(optoas(OCMP, n->type), &n1, &n2);
                 a = AJNE;
                 if(!true)
                         a = AJEQ;
-                patch(gbranch(a, n->type), to);
+                patch(gbranch(a, n->type, likely), to);
                 regfree(&n1);
                 return;
 
         case OLITERAL:
                 // need to ask if it is bool?
                 if(!true == !n->val.u.bval)
-                        patch(gbranch(AJMP, T), to);
+                        patch(gbranch(AJMP, T, 0), to);
                 return;
 
         case ONAME:
                 if(!n->addable)
                         goto def;
                 nodconst(&n1, n->type, 0);
                 gins(optoas(OCMP, n->type), n, &n1);
                 a = AJNE;
                 if(!true)
                         a = AJEQ;
-                patch(gbranch(a, n->type), to);
+                patch(gbranch(a, n->type, likely), to);
                 return;
 
         case OANDAND:
                 if(!true)
                         goto caseor;
 
         caseand:
-                p1 = gbranch(AJMP, T);
-                p2 = gbranch(AJMP, T);
+                p1 = gbranch(AJMP, T, 0);
+                p2 = gbranch(AJMP, T, 0);
                 patch(p1, pc);
-                bgen(n->left, !true, p2);
-                bgen(n->right, !true, p2);
-                p1 = gbranch(AJMP, T);
+                bgen(n->left, !true, -likely, p2);
+                bgen(n->right, !true, -likely, p2);
+                p1 = gbranch(AJMP, T, 0);
                 patch(p1, to);
                 patch(p2, pc);
                 return;
 
         case OOROR:
                 if(!true)
                         goto caseand;
 
         caseor:
-                bgen(n->left, true, to);
-                bgen(n->right, true, to);
+                bgen(n->left, true, likely, to);
+                bgen(n->right, true, likely, to);
                 return;
 
         case OEQ:
         case ONE:
         case OLT:
         case OGT:
         case OLE:
         case OGE:
                 nr = n->right;
                 if(nr == N || nr->type == T)
                         return;
 
         case ONOT:      // unary
                 nl = n->left;
                 if(nl == N || nl->type == T)
                         return;
         }
 
         switch(n->op) {
         case ONOT:
-                bgen(nl, !true, to);
+                bgen(nl, !true, likely, to);
                 break;
 
         case OEQ:
         case ONE:
         case OLT:
         case OGT:
         case OLE:
         case OGE:
                 a = n->op;
                 if(!true) {
                         if(isfloat[nl->type->etype]) {
                                 // brcom is not valid on floats when NaN is involved.
-                                p1 = gbranch(AJMP, T);
-                                p2 = gbranch(AJMP, T);
+                                p1 = gbranch(AJMP, T, 0);
+                                p2 = gbranch(AJMP, T, 0);
                                 patch(p1, pc);
                                 ll = n->ninit;  // avoid re-genning ninit
                                 n->ninit = nil;
-                                bgen(n, 1, p2);
+                                bgen(n, 1, -likely, p2);
                                 n->ninit = ll;
-                                patch(gbranch(AJMP, T), to);
+                                patch(gbranch(AJMP, T, 0), to);
                                 patch(p2, pc);
                                 break;
                         }·······························
                         a = brcom(a);
                         true = !true;
                 }
 
                 // make simplest on right
                 if(nl->op == OLITERAL || (nl->ullman < nr->ullman && nl->ullman < UINF)) {
                         a = brrev(a);
@@ skipping 10 matching lines @@
                         }
                         a = optoas(a, types[tptr]);
                         regalloc(&n1, types[tptr], N);
                         agen(nl, &n1);
                         n2 = n1;
                         n2.op = OINDREG;
                         n2.xoffset = Array_array;
                         n2.type = types[tptr];
                         nodconst(&tmp, types[tptr], 0);
                         gins(optoas(OCMP, types[tptr]), &n2, &tmp);
-                        patch(gbranch(a, types[tptr]), to);
+                        patch(gbranch(a, types[tptr], likely), to);
                         regfree(&n1);
                         break;
                 }
 
                 if(isinter(nl->type)) {
                         // front end should only leave cmp to literal nil
                         if((a != OEQ && a != ONE) || nr->op != OLITERAL) {
                                 yyerror("illegal interface comparison");
                                 break;
                         }
                         a = optoas(a, types[tptr]);
                         regalloc(&n1, types[tptr], N);
                         agen(nl, &n1);
                         n2 = n1;
                         n2.op = OINDREG;
                         n2.xoffset = 0;
                         nodconst(&tmp, types[tptr], 0);
                         gins(optoas(OCMP, types[tptr]), &n2, &tmp);
-                        patch(gbranch(a, types[tptr]), to);
+                        patch(gbranch(a, types[tptr], likely), to);
                         regfree(&n1);
                         break;
                 }
 
                 if(isfloat[nr->type->etype]) {
                         a = brrev(a);   // because the args are stacked
                         if(a == OGE || a == OGT) {
                                 // only < and <= work right with NaN; reverse if needed
                                 r = nr;
                                 nr = nl;
@@ skipping 26 matching lines @@
                                 tempname(&t2, types[TFLOAT32]);
                                 cgen(nr, &t1);
                                 cgen(nl, &t2);
                                 gmove(&t2, &tmp);
                                 gins(AFCOMFP, &t1, &tmp);
                                 gins(AFSTSW, N, &ax);
                                 gins(ASAHF, N, N);
                         }
                         if(a == OEQ) {
                                 // neither NE nor P
-                                p1 = gbranch(AJNE, T);
-                                p2 = gbranch(AJPS, T);
-                                patch(gbranch(AJMP, T), to);
+                                p1 = gbranch(AJNE, T, -likely);
+                                p2 = gbranch(AJPS, T, -likely);
+                                patch(gbranch(AJMP, T, 0), to);
                                 patch(p1, pc);
                                 patch(p2, pc);
                         } else if(a == ONE) {
                                 // either NE or P
-                                patch(gbranch(AJNE, T), to);
-                                patch(gbranch(AJPS, T), to);
+                                patch(gbranch(AJNE, T, likely), to);
+                                patch(gbranch(AJPS, T, likely), to);
                         } else
-                                patch(gbranch(optoas(a, nr->type), T), to);
+                                patch(gbranch(optoas(a, nr->type), T, likely), to);
                         break;
                 }
                 if(iscomplex[nl->type->etype]) {
-                        complexbool(a, nl, nr, true, to);
+                        complexbool(a, nl, nr, true, likely, to);
                         break;
                 }
 
                 if(is64(nr->type)) {
                         if(!nl->addable) {
                                 tempname(&n1, nl->type);
                                 cgen(nl, &n1);
                                 nl = &n1;
                         }
                         if(!nr->addable) {
                                 tempname(&n2, nr->type);
                                 cgen(nr, &n2);
                                 nr = &n2;
                         }
-                        cmp64(nl, nr, a, to);
+                        cmp64(nl, nr, a, likely, to);
                         break;
                 }
 
                 a = optoas(a, nr->type);
 
                 if(nr->ullman >= UINF) {
                         tempname(&n1, nl->type);
                         tempname(&tmp, nr->type);
                         cgen(nl, &n1);
                         cgen(nr, &tmp);
                         regalloc(&n2, nr->type, N);
                         cgen(&tmp, &n2);
                         goto cmp;
                 }
 
                 tempname(&n1, nl->type);
                 cgen(nl, &n1);
 
                 if(smallintconst(nr)) {
                         gins(optoas(OCMP, nr->type), &n1, nr);
-                        patch(gbranch(a, nr->type), to);
+                        patch(gbranch(a, nr->type, likely), to);
                         break;
                 }
 
                 tempname(&tmp, nr->type);
                 cgen(nr, &tmp);
                 regalloc(&n2, nr->type, N);
                 gmove(&tmp, &n2);
 
 cmp:
                 gins(optoas(OCMP, nr->type), &n1, &n2);
-                patch(gbranch(a, nr->type), to);
+                patch(gbranch(a, nr->type, likely), to);
                 regfree(&n2);
                 break;
         }
 }
 
 /*
  * n is on stack, either local variable
  * or return value from function call.
  * return n's offset from SP.
  */
@@ skipping 151 matching lines @@
                         gins(AMOVSL, N, N);     // MOVL *(SI)+,*(DI)+
                         q--;
                 }
                 while(c > 0) {
                         gins(AMOVSB, N, N);     // MOVB *(SI)+,*(DI)+
                         c--;
                 }
         }
 }