code review 4634073: gc: Escape analysis.

src/cmd/gc/subr.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        "go.h"
 #include        "md5.h"
 #include        "y.tab.h"
 #include        "opnames.h"
 #include        "yerr.h"
 
@@ skipping 1076 matching lines @@
                 fmtprint(fp, " g(%d)", n->vargen);
 
         if(n->lineno != 0)
                 fmtprint(fp, " l(%d)", n->lineno);
 
         if(!c && n->xoffset != BADWIDTH)
                 fmtprint(fp, " x(%lld%+d)", n->xoffset, n->stkdelta);
 
         if(n->class != 0) {
                 s = "";
-                if (n->class & PHEAP) s = ",heap";
-                if ((n->class & ~PHEAP) < nelem(classnames))
+                if(n->class & PHEAP) s = ",heap";
+                if((n->class & ~PHEAP) < nelem(classnames))
                         fmtprint(fp, " class(%s%s)", classnames[n->class&~PHEAP], s);
                 else
                         fmtprint(fp, " class(%d?%s)", n->class&~PHEAP, s);
         }
 ·
         if(n->colas != 0)
                 fmtprint(fp, " colas(%d)", n->colas);
 
         if(n->funcdepth != 0)
                 fmtprint(fp, " f(%d)", n->funcdepth);
 
-        if(n->noescape != 0)
-                fmtprint(fp, " ne(%d)", n->noescape);
+        switch(n->esc) {
+        case EscUnknown:
+                break;
+        case EscHeap:
+                fmtprint(fp, " esc(h)");
+                break;
+        case EscScope:
+                fmtprint(fp, " esc(s)");
+                break;
+        case EscNone:
+                fmtprint(fp, " esc(no)");
+                break;
+        case EscNever:
+                if(!c)
+                        fmtprint(fp, " esc(N)");
+                break;
+        default:
+                fmtprint(fp, " esc(%d)", n->esc);
+                break;
+        }
+
+        if(n->escloopdepth)
+                fmtprint(fp, " ld(%d)", n->escloopdepth);
 
         if(!c && n->typecheck != 0)
                 fmtprint(fp, " tc(%d)", n->typecheck);
 
         if(!c && n->dodata != 0)
                 fmtprint(fp, " dd(%d)", n->dodata);
 
         if(n->isddd != 0)
                 fmtprint(fp, " isddd(%d)", n->isddd);
 
@@ skipping 394 matching lines @@
 
         if(fp->flags & FmtSharp) {
                 if(n->orig != N)
                         n = n->orig;
                 exprfmt(fp, n, 0);
                 goto out;
         }
 
         switch(n->op) {
         default:
-                if (fp->flags & FmtShort)
+                if(fp->flags & FmtShort)
                         fmtprint(fp, "%O%hJ", n->op, n);
                 else
                         fmtprint(fp, "%O%J", n->op, n);
                 break;
 
         case ONAME:
         case ONONAME:
                 if(n->sym == S) {
-                        if (fp->flags & FmtShort)
+                        if(fp->flags & FmtShort)
                                 fmtprint(fp, "%O%hJ", n->op, n);
                         else
                                 fmtprint(fp, "%O%J", n->op, n);
                         break;
                 }
-                if (fp->flags & FmtShort)
+                if(fp->flags & FmtShort)
                         fmtprint(fp, "%O-%S%hJ", n->op, n->sym, n);
                 else
                         fmtprint(fp, "%O-%S%J", n->op, n->sym, n);
                 goto ptyp;
 
         case OREGISTER:
                 fmtprint(fp, "%O-%R%J", n->op, n->val.u.reg, n);
                 break;
 
         case OLITERAL:
@@ skipping 1617 matching lines @@
  */
 void
 genwrapper(Type *rcvr, Type *method, Sym *newnam, int iface)
 {
         Node *this, *fn, *call, *n, *t, *pad;
         NodeList *l, *args, *in, *out;
         Type *tpad;
         int isddd;
         Val v;
 
-        if(debug['r'])
+        if(0 && debug['r'])
                 print("genwrapper rcvrtype=%T method=%T newnam=%S\n",
                         rcvr, method, newnam);
 
         lineno = 1;     // less confusing than end of input
 
         dclcontext = PEXTERN;
         markdcl();
 
         this = nod(ODCLFIELD, newname(lookup(".this")), typenod(rcvr));
         this->left->ntype = this->right;
@@ skipping 256 matching lines @@
 
         l2 = l1->next;
         l1->next = nil;
         l2->end = (*l)->end;
         (*l)->end = l1;
 
         l1 = *l;
         listsort(&l1, f);
         listsort(&l2, f);
 
-        if ((*f)(l1->n, l2->n) < 0) {
+        if((*f)(l1->n, l2->n) < 0) {
                 *l = l1;
         } else {
                 *l = l2;
                 l2 = l1;
                 l1 = *l;
         }
 
         // now l1 == *l; and l1 < l2
 
         while ((l1 != nil) && (l2 != nil)) {
                 while ((l1->next != nil) && (*f)(l1->next->n, l2->n) < 0)
                         l1 = l1->next;
 ················
                 // l1 is last one from l1 that is < l2
                 le = l1->next;          // le is the rest of l1, first one that is >= l2
-                if (le != nil)
+                if(le != nil)
                         le->end = (*l)->end;
 
                 (*l)->end = l1;         // cut *l at l1
                 *l = concat(*l, l2);    // glue l2 to *l's tail
 
                 l1 = l2;                // l1 is the first element of *l that is < the new l2
                 l2 = le;                // ... because l2 now is the old tail of l1
         }
 
         *l = concat(*l, l2);            // any remainder·
@@ skipping 393 matching lines @@
 Strlit*
 strlit(char *s)
 {
         Strlit *t;
 ········
         t = mal(sizeof *t + strlen(s));
         strcpy(t->s, s);
         t->len = strlen(s);
         return t;
 }