code review 6962043: cmd/dist, cmd/8g: implement GO386=387/sse to choose FPU...

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 31 matching lines @@
  * generate:
  *      res = n;
  * simplifies and calls gmove.
  *
  * TODO:
  *      sudoaddable
  */
 void
 cgen(Node *n, Node *res)
 {
-        Node *nl, *nr, *r, n1, n2, nt, f0, f1;
+        Node *nl, *nr, *r, n1, n2, nt;
         Prog *p1, *p2, *p3;
         int a;
 
         if(debug['g']) {
                 dump("\ncgen-n", n);
                 dump("cgen-res", res);
         }
 
         if(n == N || n->type == T)
                 fatal("cgen: n nil");
@@ skipping 118 matching lines @@
                 case OLSH:
                 case ORSH:
                 case OAND:
                 case OOR:
                 case OXOR:
                         cgen64(n, res);
                         return;
                 }
         }
 
-        if(nl != N && isfloat[n->type->etype] && isfloat[nl->type->etype])
-                goto flt;
+        if(nl != N && isfloat[n->type->etype] && isfloat[nl->type->etype]) {
+                cgen_float(n, res);
+                return;
+        }
 
         switch(n->op) {
         default:
                 dump("cgen", n);
                 fatal("cgen %O", n->op);
                 break;
 
         case OREAL:
         case OIMAG:
         case OCOMPLEX:
@@ skipping 221 matching lines @@
                 regfree(&n1);
         }
         return;
 
 uop:    // unary
         tempname(&n1, nl->type);
         cgen(nl, &n1);
         gins(a, N, &n1);
         gmove(&n1, res);
         return;
-
-flt:    // floating-point.  387 (not SSE2) to interoperate with 8c
-        nodreg(&f0, nl->type, D_F0);
-        nodreg(&f1, n->type, D_F0+1);
-        if(nr != N)
-                goto flt2;
-
-        // unary
-        cgen(nl, &f0);
-        if(n->op != OCONV && n->op != OPLUS)
-                gins(foptoas(n->op, n->type, 0), N, N);
-        gmove(&f0, res);
-        return;
-
-flt2:   // binary
-        if(nl->ullman >= nr->ullman) {
-                cgen(nl, &f0);
-                if(nr->addable)
-                        gins(foptoas(n->op, n->type, 0), nr, &f0);
-                else {
-                        cgen(nr, &f0);
-                        gins(foptoas(n->op, n->type, Fpop), &f0, &f1);
-                }
-        } else {
-                cgen(nr, &f0);
-                if(nl->addable)
-                        gins(foptoas(n->op, n->type, Frev), nl, &f0);
-                else {
-                        cgen(nl, &f0);
-                        gins(foptoas(n->op, n->type, Frev|Fpop), &f0, &f1);
-                }
-        }
-        gmove(&f0, res);
-        return;
 }
 
 /*
  * generate an addressable node in res, containing the value of n.
  * n is an array index, and might be any size; res width is <= 32-bit.
  * returns Prog* to patch to panic call.
  */
 static Prog*
 igenindex(Node *n, Node *res, int bounded)
 {
@@ skipping 434 matching lines @@
 
 /*
  * branch gen
  *      if(n == true) goto to;
  */
 void
 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;
+        Node n1, n2, tmp;
         Prog *p1, *p2;
 
         if(debug['g']) {
                 dump("\nbgen", n);
         }
 
         if(n == N)
                 n = nodbool(1);
 
         if(n->ninit != nil)
                 genlist(n->ninit);
 
         if(n->type == T) {
                 convlit(&n, types[TBOOL]);
                 if(n->type == T)
                         return;
         }
 
         et = n->type->etype;
         if(et != TBOOL) {
                 yyerror("cgen: bad type %T for %O", n->type, n->op);
                 patch(gins(AEND, N, N), to);
                 return;
         }
+        nl = n->left;
         nr = N;
 
+        if(nl != N && isfloat[nl->type->etype]) {
+                bgen_float(n, true, likely, to);
+                return;
+        }
+
         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;
@@ skipping 64 matching lines @@
                 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, 0);
-                                p2 = gbranch(AJMP, T, 0);
-                                patch(p1, pc);
-                                ll = n->ninit;  // avoid re-genning ninit
-                                n->ninit = nil;
-                                bgen(n, 1, -likely, p2);
-                                n->ninit = ll;
-                                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);
                         r = nl;
                         nl = nr;
                         nr = r;
@@ skipping 25 matching lines @@
                         a = optoas(a, types[tptr]);
                         igen(nl, &n1, N);
                         n1.type = types[tptr];
                         nodconst(&tmp, types[tptr], 0);
                         gins(optoas(OCMP, types[tptr]), &n1, &tmp);
                         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;
-                                nl = r;
-                                a = brrev(a);
-                        }
-                        nodreg(&tmp, nr->type, D_F0);
-                        nodreg(&n2, nr->type, D_F0 + 1);
-                        nodreg(&ax, types[TUINT16], D_AX);
-                        et = simsimtype(nr->type);
-                        if(et == TFLOAT64) {
-                                if(nl->ullman > nr->ullman) {
-                                        cgen(nl, &tmp);
-                                        cgen(nr, &tmp);
-                                        gins(AFXCHD, &tmp, &n2);
-                                } else {
-                                        cgen(nr, &tmp);
-                                        cgen(nl, &tmp);
-                                }
-                                gins(AFUCOMIP, &tmp, &n2);
-                                gins(AFMOVDP, &tmp, &tmp);      // annoying pop but still better than STSW+SAHF
-                        } else {
-                                // TODO(rsc): The moves back and forth to memory
-                                // here are for truncating the value to 32 bits.
-                                // This handles 32-bit comparison but presumably
-                                // all the other ops have the same problem.
-                                // We need to figure out what the right general
-                                // solution is, besides telling people to use float64.
-                                tempname(&t1, types[TFLOAT32]);
-                                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, -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, likely), to);
-                                patch(gbranch(AJPS, T, likely), to);
-                        } else
-                                patch(gbranch(optoas(a, nr->type), T, likely), to);
-                        break;
-                }
                 if(iscomplex[nl->type->etype]) {
                         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, likely, to);
                         break;
                 }
 
-                a = optoas(a, nr->type);
-
                 if(nr->ullman >= UINF) {
                         if(!nl->addable) {
                                 tempname(&n1, nl->type);
                                 cgen(nl, &n1);
                                 nl = &n1;
                         }
                         if(!nr->addable) {
                                 tempname(&tmp, nr->type);
                                 cgen(nr, &tmp);
                                 nr = &tmp;
                         }
                         regalloc(&n2, nr->type, N);
                         cgen(nr, &n2);
+                        nr = &n2;
                         goto cmp;
                 }
 
                 if(!nl->addable) {
                         tempname(&n1, nl->type);
                         cgen(nl, &n1);
                         nl = &n1;
                 }
 
                 if(smallintconst(nr)) {
                         gins(optoas(OCMP, nr->type), nl, nr);
-                        patch(gbranch(a, nr->type, likely), to);
+                        patch(gbranch(optoas(a, nr->type), nr->type, likely), to);
                         break;
                 }
 
                 if(!nr->addable) {
                         tempname(&tmp, nr->type);
                         cgen(nr, &tmp);
                         nr = &tmp;
                 }
                 regalloc(&n2, nr->type, N);
                 gmove(nr, &n2);
+                nr = &n2;
 
 cmp:
-                gins(optoas(OCMP, nr->type), nl, &n2);
-                patch(gbranch(a, nr->type, likely), to);
-                regfree(&n2);
+                gins(optoas(OCMP, nr->type), nl, nr);
+                patch(gbranch(optoas(a, nr->type), nr->type, likely), to);
+
+                if(nl->op == OREGISTER)
+                        regfree(nl);
+                regfree(nr);
                 break;
         }
 }
 
 /*
  * n is on stack, either local variable
  * or return value from function call.
  * return n's offset from SP.
  */
 int32
@@ skipping 308 matching lines @@
                 regfree(&nodl);
         return 0;
 
 yes:
         if(freer)
                 regfree(&nodr);
         if(freel)
                 regfree(&nodl);
         return 1;
 }