code review 4634073: gc: Escape analysis.

src/cmd/gc/go.h

 // 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        <bio.h>
 
 #undef OAPPEND
 
@@ skipping 22 matching lines @@
         PRIME1          = 3,
 
         AUNK            = 100,
 
         // these values are known by runtime
         AMEM            = 0,
         ANOEQ,
         ASTRING,
         AINTER,
         ANILINTER,
-        AMEMWORD,
+        ASLICE,
+        AMEM8,
+        AMEM16,
+        AMEM32,
+        AMEM64,
+        AMEM128,
+        ANOEQ8,
+        ANOEQ16,
+        ANOEQ32,
+        ANOEQ64,
+        ANOEQ128,
 
         BADWIDTH        = -1000000000,
-        MAXWIDTH        = 1<<30
-};
+};
+
+extern vlong    MAXWIDTH;
 
 /*
  * note this is the representation
  * of the compilers string literals,
  * it is not the runtime representation
  */
 typedef struct  Strlit  Strlit;
 struct  Strlit
 {
         int32   len;
@@ skipping 79 matching lines @@
 typedef struct  Sym     Sym;
 typedef struct  Node    Node;
 typedef struct  NodeList        NodeList;
 typedef struct  Type    Type;
 typedef struct  Label   Label;
 
 struct  Type
 {
         uchar   etype;
         uchar   chan;
-        uchar   recur;          // to detect loops
         uchar   trecur;         // to detect loops
         uchar   printed;
         uchar   embedded;       // TFIELD embedded type
         uchar   siggen;
         uchar   funarg;
         uchar   copyany;
         uchar   local;          // created in this file
         uchar   deferwidth;
         uchar   broke;
         uchar   isddd;  // TFIELD is ... argument
@@ skipping 27 matching lines @@
         Strlit* note;           // literal string annotation
 
         // TARRAY
         int32   bound;          // negative is dynamic array
 
         int32   maplineno;      // first use of TFORW as map key
         int32   embedlineno;    // first use of TFORW as embedded type
 };
 #define T       ((Type*)0)
 
+enum
+{
+        EscUnknown,
+        EscHeap,
+        EscScope,
+        EscNone,
+        EscNever,
+};
+
 struct  Node
 {
         uchar   op;
         uchar   ullman;         // sethi/ullman number
         uchar   addable;        // type of addressability - 0 is not addressable
         uchar   trecur;         // to detect loops
         uchar   etype;          // op for OASOP, etype for OTYPE, exclam for export
         uchar   class;          // PPARAM, PAUTO, PEXTERN, etc
         uchar   method;         // OCALLMETH name
         uchar   embedded;       // ODCLFIELD embedded type
         uchar   colas;          // OAS resulting from :=
         uchar   diag;           // already printed error about this
-        uchar   noescape;       // ONAME never move to heap
+        uchar   esc;            // EscXXX
         uchar   funcdepth;
         uchar   builtin;        // built-in name, like len or close
         uchar   walkdef;
         uchar   typecheck;
         uchar   local;
         uchar   initorder;
         uchar   dodata;         // compile literal assignment as data statement
         uchar   used;
         uchar   isddd;
         uchar   pun;            // don't registerize variable ONAME
@@ skipping 30 matching lines @@
         NodeList*       dcl;    // autodcl for this func/closure
 
         // OLITERAL/OREGISTER
         Val     val;
 
         // ONAME
         Node*   ntype;
         Node*   defn;
         Node*   pack;   // real package for import . names
         Node*   curfn;  // function for local variables
+        Type*   paramfld; // TFIELD for this PPARAM
 
         // ONAME func param with PHEAP
         Node*   heapaddr;       // temp holding heap address of param
         Node*   stackparam;     // OPARAM node referring to stack copy of param
         Node*   alloc;  // allocation call
 
         // ONAME closure param with PPARAMREF
         Node*   outer;  // outer PPARAMREF in nested closure
         Node*   closure;        // ONAME/PHEAP <-> ONAME/PPARAMREF
 
         // OPACK
         Pkg*    pkg;
 
         // Escape analysis.
-        NodeList* asrc;         // asymmetric flow(this, src)
+        NodeList* escflowsrc;   // flow(this, src)
+        int     escloopdepth;   // -1: global, 0: not set, function top level:1, increased inside function for every loop or label to mark scopes
+        int     escfloodgen;    // increased for every flood to detect loops
 
         Sym*    sym;            // various
         int32   vargen;         // unique name for OTYPE/ONAME
         int32   lineno;
         int32   endlineno;
         vlong   xoffset;
         int32   stkdelta;       // offset added by stack frame compaction phase.
         int32   ostk;
         int32   iota;
 };
@@ skipping 15 matching lines @@
         SymUniq         = 1<<3,
         SymSiggen       = 1<<4,
 };
 
 struct  Sym
 {
         ushort  lexical;
         uchar   flags;
         uchar   sym;            // huffman encoding in object file
         Sym*    link;
+        int32   npkg;   // number of imported packages with this name
 
         // saved and restored by dcopy
         Pkg*    pkg;
         char*   name;           // variable name
         Node*   def;            // definition: ONAME OTYPE OPACK or OLITERAL
         Label*  label;  // corresponding label (ephemeral)
         int32   block;          // blocknumber to catch redeclaration
         int32   lastlineno;     // last declaration for diagnostic
 };
 #define S       ((Sym*)0)
@@ skipping 68 matching lines @@
         OINDEX, OINDEXMAP,
         OKEY, OPARAM,
         OLEN,
         OMAKE, OMAKECHAN, OMAKEMAP, OMAKESLICE,
         OHMUL, ORRC, OLRC,      // high-mul and rotate-carry
         OMUL, ODIV, OMOD, OLSH, ORSH, OAND, OANDNOT,
         ONEW,
         ONOT, OCOM, OPLUS, OMINUS,
         OOROR,
         OPANIC, OPRINT, OPRINTN,
+        OPAREN,
         OSEND,
         OSLICE, OSLICEARR, OSLICESTR,
         ORECOVER,
         ORECV,
         ORUNESTR,
         OSELRECV,
         OSELRECV2,
         OIOTA,
         OREAL, OIMAG, OCOMPLEX,
 
@@ skipping 20 matching lines @@
         OTCHAN,
         OTMAP,
         OTSTRUCT,
         OTINTER,
         OTFUNC,
         OTARRAY,
         OTPAREN,
 
         // misc
         ODDD,
+        ODDDARG,
 
         // for back ends
         OCMP, ODEC, OEXTEND, OINC, OREGISTER, OINDREG,
 
         OEND,
 };
 enum
 {
         Txxx,                   // 0
 
@@ skipping 79 matching lines @@
         Etop = 1<<1,            // evaluated at statement level
         Erv = 1<<2,             // evaluated in value context
         Etype = 1<<3,
         Ecall = 1<<4,           // call-only expressions are ok
         Efnstruct = 1<<5,       // multivalue function returns are ok
         Eiota = 1<<6,           // iota is ok
         Easgn = 1<<7,           // assigning to expression
         Eindir = 1<<8,          // indirecting through expression
         Eaddr = 1<<9,           // taking address of expression
         Eproc = 1<<10,          // inside a go statement
+        Ecomplit = 1<<11,       // type in composite literal
 };
 
 #define BITS    5
 #define NVAR    (BITS*sizeof(uint32)*8)
 
 typedef struct  Bits    Bits;
 struct  Bits
 {
         uint32  b[BITS];
 };
@@ skipping 146 matching lines @@
 
 EXTERN  char*   infile;
 EXTERN  char*   outfile;
 EXTERN  Biobuf* bout;
 EXTERN  int     nerrors;
 EXTERN  int     nsavederrors;
 EXTERN  int     nsyntaxerrors;
 EXTERN  int     safemode;
 EXTERN  char    namebuf[NSYMB];
 EXTERN  char    lexbuf[NSYMB];
+EXTERN  char    litbuf[NSYMB];
 EXTERN  char    debug[256];
 EXTERN  Sym*    hash[NHASH];
 EXTERN  Sym*    importmyname;   // my name for package
 EXTERN  Pkg*    localpkg;       // package being compiled
 EXTERN  Pkg*    importpkg;      // package being imported
 EXTERN  Pkg*    structpkg;      // package that declared struct, during import
 EXTERN  Pkg*    builtinpkg;     // fake package for builtins
 EXTERN  Pkg*    gostringpkg;    // fake pkg for Go strings
 EXTERN  Pkg*    runtimepkg;     // package runtime
 EXTERN  Pkg*    stringpkg;      // fake package for C strings
@@ skipping 61 matching lines @@
 EXTERN  Node*   typesw;
 EXTERN  Node*   nblank;
 
 extern  int     thechar;
 extern  char*   thestring;
 EXTERN  char*   hunk;
 EXTERN  int32   nhunk;
 EXTERN  int32   thunk;
 
 EXTERN  int     exporting;
+EXTERN  int     erroring;
 EXTERN  int     noargnames;
 
 EXTERN  int     funcdepth;
 EXTERN  int     typecheckok;
 EXTERN  int     packagequotes;
 EXTERN  int     longsymnames;
 EXTERN  int     compiling_runtime;
 
 /*
  *      y.tab.c
@@ skipping 100 matching lines @@
 void    testdclstack(void);
 Node*   typedcl0(Sym *s);
 Node*   typedcl1(Node *n, Node *t, int local);
 void    typedcl2(Type *pt, Type *t);
 Node*   typenod(Type *t);
 NodeList*       variter(NodeList *vl, Node *t, NodeList *el);
 
 /*
  *      esc.c
  */
-void    escanalfunc(Node *func);
-void    escanalfinish();
+void    escapes(void);
 
 /*
  *      export.c
  */
 void    autoexport(Node *n, int ctxt);
 void    dumpexport(void);
 int     exportname(char *s);
 void    exportsym(Node *n);
 void    importconst(Sym *s, Type *t, Node *n);
 void    importmethod(Sym *s, Type *t);
@@ skipping 122 matching lines @@
 void    typecheckrange(Node *n);
 void    walkrange(Node *n);
 
 /*
  *      reflect.c
  */
 void    dumptypestructs(void);
 Type*   methodfunc(Type *f, Type*);
 Node*   typename(Type *t);
 Sym*    typesym(Type *t);
+int     haspointers(Type *t);
 
 /*
  *      select.c
  */
 void    typecheckselect(Node *sel);
 void    walkselect(Node *sel);
 
 /*
  *      sinit.c
  */
@@ skipping 50 matching lines @@
 int     implements(Type *t, Type *iface, Type **missing, Type **have, int *ptr);
 void    importdot(Pkg *opkg, Node *pack);
 int     is64(Type *t);
 int     isblank(Node *n);
 int     isfixedarray(Type *t);
 int     isideal(Type *t);
 int     isinter(Type *t);
 int     isnil(Node *n);
 int     isnilinter(Type *t);
 int     isptrto(Type *t, int et);
-int     isselect(Node *n);
 int     isslice(Type *t);
 int     istype(Type *t, int et);
 void    linehist(char *file, int32 off, int relative);
 NodeList*       list(NodeList *l, Node *n);
 NodeList*       list1(Node *n);
 void    listsort(NodeList**, int(*f)(Node*, Node*));
 Node*   liststmt(NodeList *l);
 NodeList*       listtreecopy(NodeList *l);
 Sym*    lookup(char *name);
 void*   mal(int32 n);
@@ skipping 10 matching lines @@
 Node*   nodnil(void);
 int     parserline(void);
 Sym*    pkglookup(char *name, Pkg *pkg);
 int     powtwo(Node *n);
 Type*   ptrto(Type *t);
 void*   remal(void *p, int32 on, int32 n);
 Sym*    restrictlookup(char *name, Pkg *pkg);
 Node*   safeexpr(Node *n, NodeList **init);
 void    saveerrors(void);
 Node*   cheapexpr(Node *n, NodeList **init);
+Node*   localexpr(Node *n, Type *t, NodeList **init);
 int32   setlineno(Node *n);
 void    setmaxarg(Type *t);
 Type*   shallow(Type *t);
 int     simsimtype(Type *t);
 void    smagic(Magic *m);
 Type*   sortinter(Type *t);
 uint32  stringhash(char *p);
 Strlit* strlit(char *s);
 int     structcount(Type *t);
 Type*   structfirst(Iter *s, Type **nn);
@@ skipping 106 matching lines @@
 Node*   nodarg(Type*, int);
 void    nopout(Prog*);
 void    patch(Prog*, Prog*);
 Prog*   unpatch(Prog*);
 void    zfile(Biobuf *b, char *p, int n);
 void    zhist(Biobuf *b, int line, vlong offset);
 void    zname(Biobuf *b, Sym *s, int t);
 void    data(void);
 void    text(void);