code review 66930044: cmd/gc: fix walkcompare bugs.

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 3153 matching lines @@
                         li = nod(OINDEX, l, nodintconst(i));
                         ri = nod(OINDEX, r, nodintconst(i));
                         a = nod(n->op, li, ri);
                         if(expr == N)
                                 expr = a;
                         else
                                 expr = nod(andor, expr, a);
                 }
                 if(expr == N)
                         expr = nodbool(n->op == OEQ);
-                typecheck(&expr, Erv);
-                walkexpr(&expr, init);
-                expr->type = n->type;
-                *np = expr;
-                return;
+                r = expr;
+                goto ret;
         }
-        
+
         if(t->etype == TSTRUCT && countfield(t) <= 4) {
                 // Struct of four or fewer fields.
                 // Inline comparisons.
                 for(t1=t->type; t1; t1=t1->down) {
                         if(isblanksym(t1->sym))
                                 continue;
                         li = nod(OXDOT, l, newname(t1->sym));
                         ri = nod(OXDOT, r, newname(t1->sym));
                         a = nod(n->op, li, ri);
                         if(expr == N)
                                 expr = a;
                         else
                                 expr = nod(andor, expr, a);
                 }
                 if(expr == N)
                         expr = nodbool(n->op == OEQ);
-                typecheck(&expr, Erv);
-                walkexpr(&expr, init);
-                expr->type = n->type;
-                *np = expr;
-                return;
+                r = expr;
+                goto ret;
         }
-        
+
         // 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.
         // 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);
@@ skipping 12 matching lines @@
         // 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;
+        goto ret;
 
 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
         // the argument space than temporary variable space.
         fn = syslook("equal", 1);
         l = n->left;
         r = n->right;
         argtype(fn, n->left->type);
         argtype(fn, n->left->type);
         r = mkcall1(fn, n->type, init, typename(n->left->type), l, r);
         if(n->op == ONE) {
                 r = nod(ONOT, r, N);
-                typecheck(&r, Erv);
+        }
+        goto ret;
+
+ret:
+        typecheck(&r, Erv);
+        walkexpr(&r, init);
+        if(r->type != n->type) {
+                r = nod(OCONVNOP, r, N);
+                r->type = n->type;
+                r->typecheck = 1;
         }
         *np = r;
         return;
 }
 
 static int
 samecheap(Node *a, Node *b)
 {
         Node *ar, *br;
         while(a != N && b != N && a->op == b->op) {
@@ skipping 587 matching lines @@
            !candiscardlist(n->ninit) ||
            !candiscardlist(n->nbody) ||
            !candiscardlist(n->nelse) ||
            !candiscardlist(n->list) ||
            !candiscardlist(n->rlist)) {
                 return 0;
         }
 ········
         return 1;
 }