code review 4634073: gc: Escape analysis.

src/cmd/gc/gen.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.
 
 /*
  * portable half of code generator.
  * mainly statements and control flow.
  */
 
 #include "go.h"
 
 static void     cgen_dcl(Node *n);
 static void     cgen_proc(Node *n, int proc);
-static void checkgoto(Node*, Node*);
+static void     checkgoto(Node*, Node*);
 
 static Label *labellist;
 static Label *lastlabel;
 
 Node*
 sysfunc(char *name)
 {
         Node *n;
 
         n = newname(pkglookup(name, runtimepkg));
@@ skipping 23 matching lines @@
                 n = l->n;
                 if(n->op == ONAME && n->class == PHEAP-1) {
                         // heap address variable; finish the job
                         // started in addrescapes.
                         s = n->sym;
                         tempname(n, n->type);
                         n->sym = s;
                 }
                 if(n->op != ONAME || n->class != PAUTO)
                         continue;
-                if (n->xoffset != BADWIDTH)
+                if(n->xoffset != BADWIDTH)
                         continue;
                 if(n->type == T)
                         continue;
                 dowidth(n->type);
                 w = n->type->width;
                 if(w >= MAXWIDTH)
                         fatal("bad width");
                 stksize += w;
                 stksize = rnd(stksize, n->type->align);
                 if(thechar == '5')
@@ skipping 12 matching lines @@
 addrescapes(Node *n)
 {
         char buf[100];
         switch(n->op) {
         default:
                 // probably a type error already.
                 // dump("addrescapes", n);
                 break;
 
         case ONAME:
-                if(n->noescape)
-                        break;
+                if(n == nodfp)
+                        break;
+
+                // if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
+                // on PPARAM it means something different.
+                if(n->class == PAUTO && n->esc == EscNever)
+                        break;
+
+                if(!debug['s'] && n->esc != EscUnknown)
+                        fatal("without escape analysis, only PAUTO's should have esc: %N", n);
+
                 switch(n->class) {
                 case PPARAMREF:
                         addrescapes(n->defn);
                         break;
                 case PPARAM:
                 case PPARAMOUT:
                         // if func param, need separate temporary
                         // to hold heap pointer.
                         // the function type has already been checked
                         // (we're in the function body)
                         // so the param already has a valid xoffset.
 
                         // expression to refer to stack copy
                         n->stackparam = nod(OPARAM, n, N);
                         n->stackparam->type = n->type;
                         n->stackparam->addable = 1;
                         if(n->xoffset == BADWIDTH)
                                 fatal("addrescapes before param assignment");
                         n->stackparam->xoffset = n->xoffset;
-                        n->xoffset = 0;
                         // fallthrough
                 case PAUTO:
 
                         n->class |= PHEAP;
                         n->addable = 0;
                         n->ullman = 2;
                         n->xoffset = 0;
 
                         // create stack variable to hold pointer to heap
                         n->heapaddr = nod(ONAME, N, N);
                         n->heapaddr->type = ptrto(n->type);
                         snprint(buf, sizeof buf, "&%S", n->sym);
                         n->heapaddr->sym = lookup(buf);
                         n->heapaddr->class = PHEAP-1;   // defer tempname to allocparams
                         n->heapaddr->ullman = 1;
                         n->curfn->dcl = list(n->curfn->dcl, n->heapaddr);
 
-//                      print("moved to heap: %N\n", n);
+                        if(debug['s'])
+                                n->esc = EscHeap;
+
+                        if(debug['m'])
+                                print("%L: moved to heap: %hN\n", n->lineno, n);
 
                         break;
                 }
                 break;
 
         case OIND:
         case ODOTPTR:
                 break;
 
         case ODOT:
@@ skipping 683 matching lines @@
 void
 tempname(Node *nn, Type *t)
 {
         Node *n;
         Sym *s;
         uint32 w;
 
         if(stksize < 0)
                 fatal("tempname not during code generation");
 
-        if (curfn == N)
+        if(curfn == N)
                 fatal("no curfn for tempname");
 
         if(t == T) {
                 yyerror("tempname called with nil type");
                 t = types[TINT32];
         }
 
         // give each tmp a different name so that there
         // a chance to registerizer them
         snprint(namebuf, sizeof(namebuf), "autotmp_%.4d", statuniqgen);
         statuniqgen++;
         s = lookup(namebuf);
         n = nod(ONAME, N, N);
         n->sym = s;
         n->type = t;
         n->class = PAUTO;
         n->addable = 1;
         n->ullman = 1;
-        n->noescape = 1;
+        n->esc = EscNever;
         n->curfn = curfn;
         curfn->dcl = list(curfn->dcl, n);
 
         dowidth(t);
         w = t->width;
         stksize += w;
         stksize = rnd(stksize, t->align);
         if(thechar == '5')
                 stksize = rnd(stksize, widthptr);
         n->xoffset = -stksize;
 
         //      print("\ttmpname (%d): %N\n", stksize, n);
 
         *nn = *n;
 }