code review 4634073: gc: Escape analysis.

src/cmd/gc/lex.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.
 
-#define         EXTERN
 #include        "go.h"
 #include        "y.tab.h"
 #include        <ar.h>
 
 #undef  getc
 #undef  ungetc
 #define getc    ccgetc
 #define ungetc  ccungetc
 
 extern int yychar;
@@ skipping 195 matching lines @@
                 curio.bin = Bopen(infile, OREAD);
                 if(curio.bin == nil) {
                         print("open %s: %r\n", infile);
                         errorexit();
                 }
                 curio.peekc = 0;
                 curio.peekc1 = 0;
                 curio.nlsemi = 0;
 
                 block = 1;
+                iota = -1000000;
 
                 yyparse();
                 if(nsyntaxerrors != 0)
                         errorexit();
 
                 linehist(nil, 0, 0);
                 if(curio.bin != nil)
                         Bterm(curio.bin);
         }
         testdclstack();
@@ skipping 15 matching lines @@
 
         // Phase 2: Variable assignments.
         //   To check interface assignments, depends on phase 1.
         for(l=xtop; l; l=l->next)
                 if(l->n->op == ODCL || l->n->op == OAS)
                         typecheck(&l->n, Etop);
         resumetypecopy();
         resumecheckwidth();
 
         // Phase 3: Type check function bodies.
-        for(l=xtop; l; l=l->next)
-                if(l->n->op == ODCLFUNC) {
+        for(l=xtop; l; l=l->next) {
+                if(l->n->op == ODCLFUNC || l->n->op == OCLOSURE) {
                         curfn = l->n;
                         saveerrors();
                         typechecklist(l->n->nbody, Etop);
                         if(nerrors != 0)
                                 l->n->nbody = nil;  // type errors; do not compile
                 }
+        }
+
         curfn = nil;
+········
+        if(nsavederrors+nerrors)
+                errorexit();
 
         // Phase 3b: escape analysis.
-        if (debug['s']) {
-        for(l=xtop; l; l=l->next)
-                if(l->n->op == ODCLFUNC)
-                        escanalfunc(l->n);
-        escanalfinish();
-        }
+        if(debug['s'])
+                escapes();
 
         // Phase 4: Compile function bodies.
         for(l=xtop; l; l=l->next)
                 if(l->n->op == ODCLFUNC)
                         funccompile(l->n, 0);
 
         if(nsavederrors+nerrors == 0)
                 fninit(xtop);
 
         // Phase 4b: Compile all closures.
         while(closures) {
                 l = closures;
                 closures = nil;
-                for(; l; l=l->next)
+                for(; l; l=l->next) {
                         funccompile(l->n, 1);
+                }
         }
 
         // Phase 5: check external declarations.
         for(l=externdcl; l; l=l->next)
                 if(l->n->op == ONAME)
                         typecheck(&l->n, Erv);
 
         if(nerrors+nsavederrors)
                 errorexit();
 
@@ skipping 99 matching lines @@
                 snprint(namebuf, sizeof(namebuf), "%Z.a", name);
                 if(access(namebuf, 0) >= 0)
                         return 1;
                 snprint(namebuf, sizeof(namebuf), "%Z.%c", name, thechar);
                 if(access(namebuf, 0) >= 0)
                         return 1;
                 return 0;
         }
 
         // local imports should be canonicalized already.
-        // don't want to see "container/../container/vector"
-        // as different from "container/vector".
+        // don't want to see "encoding/../encoding/base64"
+        // as different from "encoding/base64".
         q = mal(name->len+1);
         memmove(q, name->s, name->len);
         q[name->len] = '\0';
         cleanname(q);
         if(strlen(q) != name->len || memcmp(q, name->s, name->len) != 0) {
                 yyerror("non-canonical import path %Z (should be %s)", name, q);
                 return 0;
         }
 
         for(p = idirs; p != nil; p = p->link) {
@@ skipping 313 matching lines @@
                 }
 
         strlit:
                 *(int32*)cp = clen-sizeof(int32);       // length
                 do {
                         cp[clen++] = 0;
                 } while(clen & MAXALIGN);
                 yylval.val.u.sval = (Strlit*)cp;
                 yylval.val.ctype = CTSTR;
                 DBG("lex: string literal\n");
+                strcpy(litbuf, "string literal");
                 return LLITERAL;
 
         case '\'':
                 /* '.' */
                 if(escchar('\'', &escflag, &v)) {
                         yyerror("empty character literal or unescaped ' in character literal");
                         v = '\'';
                 }
                 if(!escchar('\'', &escflag, &v)) {
                         yyerror("missing '");
                         ungetc(v);
                 }
                 yylval.val.u.xval = mal(sizeof(*yylval.val.u.xval));
                 mpmovecfix(yylval.val.u.xval, v);
                 yylval.val.ctype = CTINT;
                 DBG("lex: codepoint literal\n");
+                strcpy(litbuf, "string literal");
                 return LLITERAL;
 
         case '/':
                 c1 = getc();
                 if(c1 == '*') {
                         int nl;
 ························
                         nl = 0;
                         for(;;) {
                                 c = getr();
@@ skipping 369 matching lines @@
         ungetc(c);
 
         yylval.val.u.xval = mal(sizeof(*yylval.val.u.xval));
         mpatofix(yylval.val.u.xval, lexbuf);
         if(yylval.val.u.xval->ovf) {
                 yyerror("overflow in constant");
                 mpmovecfix(yylval.val.u.xval, 0);
         }
         yylval.val.ctype = CTINT;
         DBG("lex: integer literal\n");
+        strcpy(litbuf, "literal ");
+        strcat(litbuf, lexbuf);
         return LLITERAL;
 
 casedot:
         for(;;) {
                 if(cp+10 >= ep) {
                         yyerror("identifier too long");
                         errorexit();
                 }
                 *cp++ = c;
                 c = getc();
@@ skipping 52 matching lines @@
         *cp = 0;
         yylval.val.u.cval = mal(sizeof(*yylval.val.u.cval));
         mpmovecflt(&yylval.val.u.cval->real, 0.0);
         mpatoflt(&yylval.val.u.cval->imag, lexbuf);
         if(yylval.val.u.cval->imag.val.ovf) {
                 yyerror("overflow in imaginary constant");
                 mpmovecflt(&yylval.val.u.cval->real, 0.0);
         }
         yylval.val.ctype = CTCPLX;
         DBG("lex: imaginary literal\n");
+        strcpy(litbuf, "literal ");
+        strcat(litbuf, lexbuf);
         return LLITERAL;
 
 caseout:
         *cp = 0;
         ungetc(c);
 
         yylval.val.u.fval = mal(sizeof(*yylval.val.u.fval));
         mpatoflt(yylval.val.u.fval, lexbuf);
         if(yylval.val.u.fval->val.ovf) {
                 yyerror("overflow in float constant");
                 mpmovecflt(yylval.val.u.fval, 0.0);
         }
         yylval.val.ctype = CTFLT;
         DBG("lex: floating literal\n");
+        strcpy(litbuf, "literal ");
+        strcat(litbuf, lexbuf);
         return LLITERAL;
 }
 
 /*
  * read and interpret syntax that looks like
  * //line parse.y:15
  * as a discontinuity in sequential line numbers.
  * the next line of input comes from parse.y:15
  */
 static int
@@ skipping 486 matching lines @@
                 s->def->sym = s;
         }
 
         s = lookup("false");
         if(s->def == N) {
                 s->def = nodbool(0);
                 s->def->sym = s;
         }
 ········
         nodfp = nod(ONAME, N, N);
-        nodfp->noescape = 1;
         nodfp->type = types[TINT32];
         nodfp->xoffset = 0;
         nodfp->class = PPARAM;
         nodfp->sym = lookup(".fp");
 }
 
 struct
 {
         int     lex;
         char*   name;
@@ skipping 113 matching lines @@
 static void
 yytinit(void)
 {
         int i, j;
         extern char *yytname[];
         char *s, *t;
 
         for(i=0; yytname[i] != nil; i++) {
                 s = yytname[i];
 ················
+                if(strcmp(s, "LLITERAL") == 0) {
+                        strcpy(litbuf, "literal");
+                        yytname[i] = litbuf;
+                        goto loop;
+                }
+················
                 // apply yytfix if possible
                 for(j=0; j<nelem(yytfix); j++) {
                         if(strcmp(s, yytfix[j].have) == 0) {
                                 yytname[i] = yytfix[j].want;
                                 goto loop;
                         }
                 }
 
                 // turn 'x' into x.
                 if(s[0] == '\'') {
@@ skipping 54 matching lines @@
                         p = infile;
                 else
                         p = p+1;
                 snprint(namebuf, sizeof(namebuf), "%s", p);
                 p = strrchr(namebuf, '.');
                 if(p != nil)
                         *p = 0;
                 outfile = smprint("%s.%c", namebuf, thechar);
         }
 }