code review 6280049: cmd/gc: inline convT2E when T is uintptr-shaped.

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        <bio.h>
 
 #undef OAPPEND
 
 // avoid <ctype.h>
 #undef isblank
@@ skipping 164 matching lines @@
 
         // TFIELD
         Type*   down;           // also used in TMAP
         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
+········
+        // for TFORW, where to copy the eventual value to
+        NodeList        *copyto;
 };
 #define T       ((Type*)0)
 
 typedef struct InitEntry InitEntry;
 typedef struct InitPlan InitPlan;
 
 struct InitEntry
 {
         vlong xoffset;  // struct, array only
         Node *key;  // map only
@@ skipping 283 matching lines @@
         OTSTRUCT,
         OTINTER,
         OTFUNC,
         OTARRAY,
         OTPAREN,
 
         // misc
         ODDD,
         ODDDARG,
         OINLCALL,       // intermediary representation of an inlined call
-        OIFACE, // itable and data words of interface value
+        OEFACE, // itable and data words of empty-interface value
         OITAB,  // itable word of interface value
 
         // for back ends
         OCMP, ODEC, OEXTEND, OINC, OREGISTER, OINDREG,
         OLROT,
 
         OEND,
 };
 enum
 {
@@ skipping 437 matching lines @@
 void    funccompile(Node *n, int isclosure);
 void    funchdr(Node *n);
 Type*   functype(Node *this, NodeList *in, NodeList *out);
 void    ifacedcl(Node *n);
 int     isifacemethod(Type *f);
 void    markdcl(void);
 Node*   methodname(Node *n, Type *t);
 Node*   methodname1(Node *n, Node *t);
 Sym*    methodsym(Sym *nsym, Type *t0, int iface);
 Node*   newname(Sym *s);
-Type*   newtype(Sym *s);
 Node*   oldname(Sym *s);
 void    popdcl(void);
 void    poptodcl(void);
 void    redeclare(Sym *s, char *where);
 void    testdclstack(void);
 Type*   tointerface(NodeList *l);
 Type*   tostruct(NodeList *l);
 Node*   typedcl0(Sym *s);
 Node*   typedcl1(Node *n, Node *t, int local);
 Node*   typenod(Type *t);
@@ skipping 24 matching lines @@
 void    fmtinstallgo(void);
 void    dump(char *s, Node *n);
 void    dumplist(char *s, NodeList *l);
 
 /*
  *      gen.c
  */
 void    addrescapes(Node *n);
 void    cgen_as(Node *nl, Node *nr);
 void    cgen_callmeth(Node *n, int proc);
-void    cgen_iface(Node* n, Node* res);
+void    cgen_eface(Node* n, Node* res);
 void    cgen_slice(Node* n, Node* res);
 void    clearlabels(void);
 void    checklabels(void);
 int     dotoffset(Node *n, int *oary, Node **nn);
 void    gen(Node *n);
 void    genlist(NodeList *l);
 Node*   sysfunc(char *name);
 void    tempname(Node *n, Type *t);
 Node*   temp(Type*);
 
@@ skipping 244 matching lines @@
 void    typecheckswitch(Node *n);
 void    walkswitch(Node *sw);
 
 /*
  *      typecheck.c
  */
 int     islvalue(Node *n);
 Node*   typecheck(Node **np, int top);
 void    typechecklist(NodeList *l, int top);
 Node*   typecheckdef(Node *n);
-void    resumetypecopy(void);
 void    copytype(Node *n, Type *t);
-void    defertypecopy(Node *n, Type *t);
 void    queuemethod(Node *n);
 
 /*
  *      unsafe.c
  */
 int     isunsafebuiltin(Node *n);
 Node*   unsafenmagic(Node *n);
 
 /*
  *      walk.c
@@ skipping 94 matching lines @@
 #pragma varargck        type    "P"     Prog*
 #pragma varargck        type    "Q"     Bits
 #pragma varargck        type    "R"     int
 #pragma varargck        type    "S"     Sym*
 #pragma varargck        type    "lS"    Sym*
 #pragma varargck        type    "T"     Type*
 #pragma varargck        type    "lT"    Type*
 #pragma varargck        type    "V"     Val*
 #pragma varargck        type    "Y"     char*
 #pragma varargck        type    "Z"     Strlit*