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

src/cmd/gc/plive.c

 // Copyright 2013 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.
 
 // Garbage collector liveness bitmap generation.
 
 // The command line flag -live causes this code to print debug information.
 // The levels are:
 //
 //      -live (aka -live=1): print liveness lists as code warnings at safe points
@@ skipping 565 matching lines @@
 
         // Sort the basic blocks by their depth first number.  The
         // array is now a depth-first spanning tree with the first
         // node being the root.
         arraysort(cfg, blockrpocmp);
         bb = *(BasicBlock**)arrayget(cfg, 0);
 
         // Unreachable control flow nodes are indicated by a -1 in the rpo
         // field.  If we see these nodes something must have gone wrong in an
         // upstream compilation phase.
-        if(bb->rpo == -1)
-                fatal("newcfg: unreferenced basic blocks");
+        if(bb->rpo == -1) {
+                print("newcfg: unreachable basic block for %P\n", bb->last);
+                printcfg(cfg);
+                fatal("newcfg: invalid control flow graph");
+        }
 
         return cfg;
 }
 
 // Frees a control flow graph (an array of BasicBlock*s) and all of its leaf
 // data structures.
 static void
 freecfg(Array *cfg)
 {
         BasicBlock *bb;
@@ skipping 351 matching lines @@
         BasicBlock *bb;
         int32 i;
 
         for(i = 0; i < arraylength(lv->cfg); i++) {
                 bb = *(BasicBlock**)arrayget(lv->cfg, i);
                 livenessprintblock(lv, bb);
         }
 }
 
 static void
-checkauto(Node *fn, Prog *p, Node *n, char *where)
-{
-        NodeList *ll;
-        int found;
-        char *fnname;
-        char *nname;
-
-        found = 0;
-        for(ll = fn->dcl; ll != nil; ll = ll->next) {
-                if(ll->n->op == ONAME && ll->n->class == PAUTO) {
-                        if(n == ll->n) {
-                                found = 1;
-                                break;
-                        }
-                }
-        }
-        if(found)
-                return;
-        fnname = fn->nname->sym->name ? fn->nname->sym->name : "<unknown>";
-        nname = n->sym->name ? n->sym->name : "<unknown>";
-        print("D_AUTO '%s' not found: name is '%s' function is '%s' class is %d\n", where, nname, fnname, n->class);
-        print("Here '%P'\nlooking for node %p\n", p, n);
-        for(ll = fn->dcl; ll != nil; ll = ll->next)
-                print("node=%p, node->class=%d\n", (uintptr)ll->n, ll->n->class);
+checkauto(Node *fn, Prog *p, Node *n)
+{
+        NodeList *l;
+
+        for(l = fn->dcl; l != nil; l = l->next)
+                if(l->n->op == ONAME && l->n->class == PAUTO && l->n == n)
+                        return;
+
+        print("checkauto %N: %N (%p; class=%d) not found in %P\n", curfn, n, n, n->class, p);
+        for(l = fn->dcl; l != nil; l = l->next)
+                print("\t%N (%p; class=%d)\n", l->n, l->n, l->n->class);
         yyerror("checkauto: invariant lost");
 }
 
 static void
-checkparam(Node *fn, Prog *p, Node *n, char *where)
-{
-        NodeList *ll;
-        int found;
-        char *fnname;
-        char *nname;
+checkparam(Node *fn, Prog *p, Node *n)
+{
+        NodeList *l;
+        Node *a;
+        int class;
 
         if(isfunny(n))
                 return;
-        found = 0;
-        for(ll = fn->dcl; ll != nil; ll = ll->next) {
-                if(ll->n->op == ONAME && ((ll->n->class & ~PHEAP) == PPARAM ||
-                                          (ll->n->class & ~PHEAP) == PPARAMOUT)) {
-                        if(n == ll->n) {
-                                found = 1;
-                                break;
-                        }
-                }
-        }
-        if(found)
-                return;
-        if(n->sym) {
-                fnname = fn->nname->sym->name ? fn->nname->sym->name : "<unknown>";
-                nname = n->sym->name ? n->sym->name : "<unknown>";
-                print("D_PARAM '%s' not found: name='%s' function='%s' class is %d\n", where, nname, fnname, n->class);
-                print("Here '%P'\nlooking for node %p\n", p, n);
-                for(ll = fn->dcl; ll != nil; ll = ll->next)
-                        print("node=%p, node->class=%d\n", ll->n, ll->n->class);
-        }
+        for(l = fn->dcl; l != nil; l = l->next) {
+                a = l->n;
+                class = l->n->class & ~PHEAP;
+                if(a->op == ONAME && (class == PPARAM || class == PPARAMOUT) && a == n)
+                        return;
+        }
+
+        print("checkparam %N: %N (%p; class=%d) not found in %P\n", curfn, n, n, n->class, p);
+        for(l = fn->dcl; l != nil; l = l->next)
+                print("\t%N (%p; class=%d)\n", l->n, l->n, l->n->class);
         yyerror("checkparam: invariant lost");
 }
 
 static void
 checkprog(Node *fn, Prog *p)
 {
         if(p->from.type == D_AUTO)
-                checkauto(fn, p, p->from.node, "from");
+                checkauto(fn, p, p->from.node);
         if(p->from.type == D_PARAM)
-                checkparam(fn, p, p->from.node, "from");
+                checkparam(fn, p, p->from.node);
         if(p->to.type == D_AUTO)
-                checkauto(fn, p, p->to.node, "to");
+                checkauto(fn, p, p->to.node);
         if(p->to.type == D_PARAM)
-                checkparam(fn, p, p->to.node, "to");
+                checkparam(fn, p, p->to.node);
 }
 
 // Check instruction invariants.  We assume that the nodes corresponding to the
 // sources and destinations of memory operations will be declared in the
 // function.  This is not strictly true, as is the case for the so-called funny
 // nodes and there are special cases to skip over that stuff.  The analysis will
 // fail if this invariant blindly changes.
 static void
 checkptxt(Node *fn, Prog *firstp)
 {
@@ skipping 562 matching lines @@
                                 printvars("livein", livein, lv->vars);
                                 printvars("liveout", liveout, lv->vars);
                         }
                         if(issafepoint(p)) {
                                 // Found an interesting instruction, record the
                                 // corresponding liveness information.··
 ································
                                 // Useful sanity check: on entry to the function,
                                 // the only things that can possibly be live are the
                                 // input parameters.
-                                if(0 && p->as == ATEXT) {
+                                if(p->as == ATEXT) {
                                         for(j = 0; j < liveout->n; j++) {
                                                 if(!bvget(liveout, j))
                                                         continue;
                                                 n = *(Node**)arrayget(lv->vars, j);
                                                 if(n->class != PPARAM)
-                                                        yyerrorl(p->lineno, "internal error: %N %N recorded as live on entry", curfn->nname, n);
+                                                        yyerrorl(p->lineno, "internal error: %N %lN recorded as live on entry", curfn->nname, n);
                                         }
                                 }
 
                                 // Record live pointers.
                                 args = *(Bvec**)arrayget(lv->argslivepointers, pos);
                                 locals = *(Bvec**)arrayget(lv->livepointers, pos);
                                 twobitlivepointermap(lv, liveout, lv->vars, args, locals);
 
                                 // Show live pointer bitmaps.
                                 // We're interpreting the args and locals bitmap instead of liveout so that we
@@ skipping 294 matching lines @@
         if(deadsym != nil)
                 twobitwritesymbol(lv->deadvalues, deadsym, nil);
 
         // Free everything.
         freeliveness(lv);
         arrayfree(vars);
         freecfg(cfg);
 ········
         debuglive -= debugdelta;
 }