code review 8174047: cmd/gc: do not reuse bool temporaries for composite equ...

src/cmd/gc/walk.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.
 
 #include        <u.h>
 #include        <libc.h>
 #include        "go.h"
 
 static  Node*   walkprint(Node*, NodeList**, int);
 static  Node*   mapfn(char*, Type*);
@@ skipping 2735 matching lines @@
                 n++;
         return n;
 }
 
 static void
 walkcompare(Node **np, NodeList **init)
 {
         Node *n, *l, *r, *fn, *call, *a, *li, *ri, *expr;
         int andor, i;
         Type *t, *t1;
-        Node *tempbool;
+        static Node *tempbool;
 ········
         n = *np;
 ········
         // Must be comparison of array or struct.
         // Otherwise back end handles it.
         t = n->left->type;
         switch(t->etype) {
         default:
                 return;
         case TARRAY:
@@ skipping 68 matching lines @@
                 expr->type = n->type;
                 *np = expr;
                 return;
         }
 ········
         // Chose not to inline, but still have addresses.
         // Call equality function directly.
         // The equality function requires a bool pointer for
         // storing its address, because it has to be callable
         // from C, and C can't access an ordinary Go return value.
-        tempbool = temp(types[TBOOL]);
+        // To avoid creating many temporaries, cache one per function.
+        if(tempbool == N || tempbool->curfn != curfn)
+                tempbool = temp(types[TBOOL]);
 ········
         call = nod(OCALL, eqfor(t), N);
         a = nod(OADDR, tempbool, N);
         a->etype = 1;  // does not escape
         call->list = list(call->list, a);
         call->list = list(call->list, nodintconst(t->width));
         call->list = list(call->list, l);
         call->list = list(call->list, r);
         typecheck(&call, Etop);
         walkstmt(&call);
         *init = list(*init, call);

[DMorsing, 2013/03/31 10:16:01]

Make a new temporary and put a nod(OAS, newtemp, tempbool) at the end of this
list.

- ·······
-        if(n->op == OEQ)
-                r = tempbool;

[DMorsing, 2013/03/31 10:16:01]

use newtemp here and below.

-        else
-                r = nod(ONOT, tempbool, N);
+
+        // tempbool cannot be used directly as multiple comparison
+        // expressions may exist in the same statement. Create another
+        // temporary to hold the value (its address is not taken so it can
+        // be optimized away).
+        r = temp(types[TBOOL]);
+        a = nod(OAS, r, tempbool);
+        typecheck(&a, Etop);
+        walkstmt(&a);
+        *init = list(*init, a);
+
+        if(n->op != OEQ)
+                r = nod(ONOT, r, N);
         typecheck(&r, Erv);
         walkexpr(&r, init);
         *np = r;
         return;
 
 hard:
         // Cannot take address of one or both of the operands.
         // Instead, pass directly to runtime helper function.
         // Easier on the stack than passing the address
         // of temporary variables, because we are better at reusing
@@ skipping 592 matching lines @@
            !candiscardlist(n->ninit) ||
            !candiscardlist(n->nbody) ||
            !candiscardlist(n->nelse) ||
            !candiscardlist(n->list) ||
            !candiscardlist(n->rlist)) {
                 return 0;
         }
 ········
         return 1;
 }