code review 6351090: cmd/gc: Inline pointer sized T2I interface conversions

src/cmd/gc/walk.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        <u.h>
 #include        <libc.h>
 #include        "go.h"
 
 static  Node*   walkprint(Node*, NodeList**, int);
 static  Node*   mapfn(char*, Type*);
@@ skipping 356 matching lines @@
 
 void
 walkexpr(Node **np, NodeList **init)
 {
         Node *r, *l, *var, *a;
         NodeList *ll, *lr, *lpost;
         Type *t;
         int et;
         int64 v;
         int32 lno;
-        Node *n, *fn;
+        Node *n, *fn, *n1, *n2;
         Sym *sym;
         char buf[100], *p;
 
         n = *np;
 
         if(n == N)
                 return;
 
         if(init == &n->ninit) {
                 // not okay to use n->ninit when walking n,
@@ skipping 376 matching lines @@
                                 l->type = ptrto(types[TUINT8]);
                                 l->addable = 1;
                                 l->class = PEXTERN;
                                 l->xoffset = 0;
                                 sym->def = l;
                                 ggloblsym(sym, widthptr, 1, 0);
                         }
                         l = nod(OADDR, sym->def, N);
                         l->addable = 1;
                         ll = list(ll, l);
+
+                        if(n->left->type->width == widthptr &&
+                           isint[simsimtype(n->left->type)]) {
+                                /* For pointer types, we can make a special form of optimization
+                                 *
+                                 * These statements are put onto the expression init list:
+                                 *      Itab *tab = atomicloadtype(&cache);
+                                 *      if(tab == nil)
+                                 *              tab = typ2Itab(type, itype, &cache);
+                                 *
+                                 * The CONVIFACE expression is replaced with this:
+                                 *      OEFACE{tab, ptr};
+                                 */
+                                l = temp(ptrto(types[TUINT8]));
+
+                                n1 = nod(OAS, l, sym->def);
+                                typecheck(&n1, Etop);
+                                *init = list(*init, n1);
+
+                                fn = syslook("typ2Itab", 1);
+                                n1 = nod(OCALL, fn, N);
+                                n1->list = ll;
+                                typecheck(&n1, Erv);
+                                walkexpr(&n1, init);
+
+                                n2 = nod(OIF, N, N);
+                                n2->ntest = nod(OEQ, l, nodnil());
+                                n2->nbody = list1(nod(OAS, l, n1));
+                                n2->likely = -1;
+                                typecheck(&n2, Etop);
+                                *init = list(*init, n2);
+
+                                l = nod(OEFACE, l, n->left);
+                                l->typecheck = n->typecheck;·
+                                l->type = n->type;
+                                n = l;
+                                goto ret;
+                        }
                 }
                 ll = list(ll, n->left);
                 argtype(fn, n->left->type);
                 argtype(fn, n->type);
                 dowidth(fn->type);
                 n = nod(OCALL, fn, N);
                 n->list = ll;
                 typecheck(&n, Erv);
                 walkexpr(&n, init);
                 goto ret;
@@ skipping 377 matching lines @@
                 r = mkcall1(fn, n->type, init, n->left, n->right);
                 if(n->etype == ONE)
                         r = nod(ONOT, r, N);
 ················
                 // check itable/type before full compare.
                 if(n->etype == OEQ)
                         r = nod(OANDAND, nod(OEQ, nod(OITAB, n->left, N), nod(OITAB, n->right, N)), r);
                 else
                         r = nod(OOROR, nod(ONE, nod(OITAB, n->left, N), nod(OITAB, n->right, N)), r);
                 typecheck(&r, Erv);
-                walkexpr(&r, nil);
+                walkexpr(&r, init);
                 r->type = n->type;
                 n = r;
                 goto ret;
 
         case OARRAYLIT:
         case OMAPLIT:
         case OSTRUCTLIT:
         case OPTRLIT:
                 var = temp(n->type);
                 anylit(0, n, var, init);
@@ skipping 1667 matching lines @@
                         bits -= v;
                 }
                 break;
         }
 ········
         if(!sign && bits <= 62 && (1LL<<bits) <= max)
                 return 1;
 ········
         return 0;
 }