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

src/cmd/5g/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.
 
 #include <u.h>
 #include <libc.h>
 #include "gg.h"
 
 /*
  * generate:
@@ skipping 1423 matching lines @@
 
         if(w == 0) {
                 // evaluate side effects only.
                 regalloc(&dst, types[tptr], N);
                 agen(res, &dst);
                 agen(n, &dst);
                 regfree(&dst);
                 return;
         }
 
-        // Record site of definition of ns for liveness analysis.
-        if(res->op == ONAME && res->class != PEXTERN)
-                gvardef(res);
-········
         // If copying .args, that's all the results, so record definition sites
         // for them for the liveness analysis.
         if(res->op == ONAME && strcmp(res->sym->name, ".args") == 0)
                 for(l = curfn->dcl; l != nil; l = l->next)
                         if(l->n->class == PPARAMOUT)
                                 gvardef(l->n);
 
         // Avoid taking the address for simple enough types.
         if(componentgen(n, res))
                 return;
@@ skipping 38 matching lines @@
         // if we are copying forward on the stack and
         // the src and dst overlap, then reverse direction
         dir = align;
         if(osrc < odst && odst < osrc+w)
                 dir = -dir;
 
         if(n->ullman >= res->ullman) {
                 agenr(n, &dst, res);    // temporarily use dst
                 regalloc(&src, types[tptr], N);
                 gins(AMOVW, &dst, &src);
+                if(res->op == ONAME)
+                        gvardef(res);
                 agen(res, &dst);
         } else {
+                if(res->op == ONAME)
+                        gvardef(res);
                 agenr(res, &dst, res);
                 agenr(n, &src, N);
         }
 
         regalloc(&tmp, types[TUINT32], N);
 
         // set up end marker
         memset(&nend, 0, sizeof nend);
         if(c >= 4) {
                 regalloc(&nend, types[TUINT32], N);
@@ skipping 114 matching lines @@
         } else {
                 // When zeroing, prepare a register containing zero.
                 nodconst(&tmp, nl->type, 0);
                 regalloc(&nodr, types[TUINT], N);
                 gmove(&tmp, &nodr);
                 freer = 1;
         }
 
         switch(nl->type->etype) {
         case TARRAY:
+                if(nl->op == ONAME)
+                        gvardef(nl);
                 nodl.xoffset += Array_array;
                 nodl.type = ptrto(nl->type->type);
 
                 if(nr != N) {
                         nodr.xoffset += Array_array;
                         nodr.type = nodl.type;
                 }
                 gmove(&nodr, &nodl);
 
                 nodl.xoffset += Array_nel-Array_array;
@@ skipping 10 matching lines @@
 
                 if(nr != N) {
                         nodr.xoffset += Array_cap-Array_nel;
                         nodr.type = nodl.type;
                 }
                 gmove(&nodr, &nodl);
 
                 goto yes;
 
         case TSTRING:
+                if(nl->op == ONAME)
+                        gvardef(nl);
                 nodl.xoffset += Array_array;
                 nodl.type = ptrto(types[TUINT8]);
 
                 if(nr != N) {
                         nodr.xoffset += Array_array;
                         nodr.type = nodl.type;
                 }
                 gmove(&nodr, &nodl);
 
                 nodl.xoffset += Array_nel-Array_array;
                 nodl.type = types[simtype[TUINT]];
 
                 if(nr != N) {
                         nodr.xoffset += Array_nel-Array_array;
                         nodr.type = nodl.type;
                 }
                 gmove(&nodr, &nodl);
 
                 goto yes;
 
         case TINTER:
+                if(nl->op == ONAME)
+                        gvardef(nl);
                 nodl.xoffset += Array_array;
                 nodl.type = ptrto(types[TUINT8]);
 
                 if(nr != N) {
                         nodr.xoffset += Array_array;
                         nodr.type = nodl.type;
                 }
                 gmove(&nodr, &nodl);
 
                 nodl.xoffset += Array_nel-Array_array;
@@ skipping 15 matching lines @@
                 regfree(&nodl);
         return 0;
 
 yes:
         if(freer)
                 regfree(&nodr);
         if(freel)
                 regfree(&nodl);
         return 1;
 }