code review 6549052: cmd/8g: use SSE2 instructions

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;

[bradfitz, 2012/10/07 19:39:33]

remove comment?

+        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 356 matching lines @@
                 regfree(&n1);
         }
         return;
 
 uop:    // unary
         tempname(&n1, nl->type);
         cgen(nl, &n1);
         gins(a, N, &n1);
         gmove(&n1, res);
         return;
-
-/*

[bradfitz, 2012/10/07 19:39:33]

temporary?

-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.
  */
 Prog*
 igenindex(Node *n, Node *res)
 {
@@ skipping 329 matching lines @@
  * on exit, a has been changed to be *newreg.
  * caller must regfree(a).
  */
 void
 igen(Node *n, Node *a, Node *res)
 {
         Type *fp;
         Iter flist;
         Node n1;
 
+        if(debug['g']) {
+                dump("\nigen-n", n);
+        }
         switch(n->op) {
         case ONAME:
                 if((n->class&PHEAP) || n->class == PPARAMREF)
                         break;
                 *a = *n;
                 return;
 
         case OINDREG:
                 // Increase the refcount of the register so that igen's caller
                 // has to call regfree.
                 if(n->val.u.reg != D_SP)
                         reg[n->val.u.reg]++;
                 *a = *n;
                 return;
 
         case ODOT:
                 igen(n->left, a, res);
                 a->xoffset += n->xoffset;
                 a->type = n->type;
                 return;
 
         case ODOTPTR:
-                regalloc(a, types[tptr], res);
-                cgen(n->left, a);
+                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) {
                                 n1 = *a;
                                 n1.op = OINDREG;
                                 n1.type = types[TUINT8];
                                 n1.xoffset = 0;
                                 gins(ATESTB, nodintconst(0), &n1);
                         }
@@ skipping 393 matching lines @@
                 fatal("sgen copy %lld", w);
 
         if(w == 0) {
                 // evaluate side effects only.
                 tempname(&tdst, types[tptr]);
                 agen(res, &tdst);
                 agen(n, &tdst);
                 return;
         }
 
-        if (w == 8 || w == 12) {
-                if(componentgen(n, res))
-                        return;
-        }
+        // Avoid taking the address for simple enough types.
+        if(componentgen(n, res))
+                return;
 
         // offset on the stack
         osrc = stkof(n);
         odst = stkof(res);
 ········
         if(osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000)) {
                 // osrc and odst both on stack, and at least one is in
                 // an unknown position.  Could generate code to test
                 // for forward/backward copy, but instead just copy
                 // to a temporary location first.
@@ skipping 81 matching lines @@
         }
 
         switch(n->op) {
         case ONAME:
                 return 1;
         }
         return 0;
 }
 
 /*
- * copy a structure component by component
+ * copy a composite value by moving its individual components.
+ * Slices, strings and interfaces are supported.
+ * nr is N when assigning a zero value.
  * return 1 if can do, 0 if cant.
- * nr is N for copy zero
  */
 int
 componentgen(Node *nr, Node *nl)
 {
         Node nodl, nodr;
         int freel, freer;
 
         freel = 0;
         freer = 0;
 
@@ skipping 113 matching lines @@
                 regfree(&nodl);
         return 0;
 
 yes:
         if(freer)
                 regfree(&nodr);
         if(freel)
                 regfree(&nodl);
         return 1;
 }