code review 64170043: cmd/gc: correct liveness for fat variables

src/cmd/8g/ggen.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.
 
 #undef  EXTERN
 #define EXTERN
 #include <u.h>
 #include <libc.h>
 #include "gg.h"
 #include "opt.h"
@@ skipping 12 matching lines @@
         frame = rnd(maxstksize+maxarg, widthptr);
         ptxt->to.offset = frame;
         maxstksize = 0;
 }
 
 // Sweep the prog list to mark any used nodes.
 void
 markautoused(Prog* p)
 {
         for (; p; p = p->link) {
-                if (p->as == ATYPE)
+                if (p->as == ATYPE || p->as == AVARDEF)
                         continue;
 
-                if (p->from.type == D_AUTO && p->from.node)
+                if (p->from.node)
                         p->from.node->used = 1;
 
-                if (p->to.type == D_AUTO && p->to.node)
+                if (p->to.node)
                         p->to.node->used = 1;
         }
 }
 
 // Fixup instructions after allocauto (formerly compactframe) has moved all autos around.
 void
 fixautoused(Prog* p)
 {
         Prog **lp;
 
         for (lp=&p; (p=*lp) != P; ) {
                 if (p->as == ATYPE && p->from.node && p->from.type == D_AUTO && !p->from.node->used) {
                         *lp = p->link;
                         continue;
                 }
+                if (p->as == AVARDEF && p->to.node && !p->to.node->used) {
+                        // Cannot remove VARDEF instruction, because - unlike TYPE handled above -
+                        // VARDEFs are interspersed with other code, and a jump might be using the
+                        // VARDEF as a target. Replace with a no-op instead. A later pass will remove
+                        // the no-ops.
+                        p->to.type = D_NONE;
+                        p->to.node = N;
+                        p->as = ANOP;
+                        continue;
+                }
 
                 if (p->from.type == D_AUTO && p->from.node)
                         p->from.offset += p->from.node->stkdelta;
 
                 if (p->to.type == D_AUTO && p->to.node)
                         p->to.offset += p->to.node->stkdelta;
 
                 lp = &p->link;
         }
 }
 
 void
 clearfat(Node *nl)
 {
         uint32 w, c, q;
         Node n1;
 
         /* clear a fat object */
         if(debug['g'])
                 dump("\nclearfat", nl);
-
-        gvardef(nl);
 
         w = nl->type->width;
         // Avoid taking the address for simple enough types.
         if(componentgen(N, nl))
                 return;
 
         c = w % 4;      // bytes
         q = w / 4;      // quads
 
         nodreg(&n1, types[tptr], D_DI);
@@ skipping 1135 matching lines @@
                 // which will be shorter to encode than plain 0.
                 p2->as = AMOVL;
                 p2->from.type = D_AX;
                 if(regtyp(&p->from))
                         p2->to.type = p->from.type + D_INDIR;
                 else
                         p2->to.type = D_INDIR+D_NONE;
                 p2->to.offset = 0;
         }
 }