code review 9101048: cmd/gc: inline copy in frontend to call memmove directly.

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 157 matching lines @@
         case OPRINTN:
         case OPANIC:
         case OEMPTY:
         case ORECOVER:
                 if(n->typecheck == 0)
                         fatal("missing typecheck: %+N", n);
                 init = n->ninit;
                 n->ninit = nil;
                 walkexpr(&n, &init);
                 addinit(&n, init);
+                if((*np)->op == OCOPY && n->op == OCONVNOP)
+                        n->op = OEMPTY; // don't leave plain values as statements.
                 break;
 
         case OBREAK:
         case ODCL:
         case OCONTINUE:
         case OFALL:
         case OGOTO:
         case OLABEL:
         case ODCLCONST:
         case ODCLTYPE:
-        case OCHECKNOTNIL:
+        case OCHECKNIL:
                 break;
 
         case OBLOCK:
                 walkstmtlist(n->list);
                 break;
 
         case OXCASE:
                 yyerror("case statement out of place");
                 n->op = OCASE;
         case OCASE:
@@ skipping 77 matching lines @@
                         // move function calls out, to make reorder3's job easier.
                         walkexprlistsafe(n->list, &n->ninit);
                         ll = ascompatee(n->op, rl, n->list, &n->ninit);
                         n->list = reorder3(ll);
                         break;
                 }
                 ll = ascompatte(n->op, nil, 0, getoutarg(curfn->type), n->list, 1, &n->ninit);
                 n->list = ll;
                 break;
 
+        case ORETJMP:
+                break;
+
         case OSELECT:
                 walkselect(n);
                 break;
 
         case OSWITCH:
                 walkswitch(n);
                 break;
 
         case ORANGE:
                 walkrange(n);
                 break;
 
         case OXFALL:
                 yyerror("fallthrough statement out of place");
                 n->op = OFALL;
                 break;
         }
 
         if(n->op == ONAME)
                 fatal("walkstmt ended up with name: %+N", n);
-
+        
         *np = n;
 }
 
 
 /*
  * walk the whole tree of the body of an
  * expression or simple statement.
  * the types expressions are calculated.
  * compile-time constants are evaluated.
  * complex side effects like statements are appended to init
@@ skipping 14 matching lines @@
                 walkexpr(&l->n, init);
         }
 }
 
 void
 walkexpr(Node **np, NodeList **init)
 {
         Node *r, *l, *var, *a;
         NodeList *ll, *lr, *lpost;
         Type *t;
-        int et;
+        int et, old_safemode;
         int64 v;
         int32 lno;
         Node *n, *fn, *n1, *n2;
         Sym *sym;
         char buf[100], *p;
 
         n = *np;
 
         if(n == N)
                 return;
@@ skipping 44 matching lines @@
         case OCOM:
         case OREAL:
         case OIMAG:
         case ODOTMETH:
         case ODOTINTER:
                 walkexpr(&n->left, init);
                 goto ret;
 
         case OIND:
                 if(n->left->type->type->width == 0) {
+                        // No actual copy will be generated, so emit an explicit nil check.
                         n->left = cheapexpr(n->left, init);
-                        checknotnil(n->left, init);
+                        checknil(n->left, init);
                 }
                 walkexpr(&n->left, init);
                 goto ret;
 
         case ODOT:
                 usefield(n);
                 walkexpr(&n->left, init);
                 goto ret;
 
         case ODOTPTR:
                 usefield(n);
                 if(n->op == ODOTPTR && n->left->type->type->width == 0) {
+                        // No actual copy will be generated, so emit an explicit nil check.
                         n->left = cheapexpr(n->left, init);
-                        checknotnil(n->left, init);
+                        checknil(n->left, init);
                 }
                 walkexpr(&n->left, init);
                 goto ret;
 
         case OEFACE:
                 walkexpr(&n->left, init);
                 walkexpr(&n->right, init);
                 goto ret;
 
         case OSPTR:
@@ skipping 46 matching lines @@
         case OXOR:
                 walkexpr(&n->left, init);
                 walkexpr(&n->right, init);
                 walkrotate(&n);
                 goto ret;
 
         case OEQ:
         case ONE:
                 walkexpr(&n->left, init);
                 walkexpr(&n->right, init);
+                // Disable safemode while compiling this code: the code we
+                // generate internally can refer to unsafe.Pointer.
+                // In this case it can happen if we need to generate an ==
+                // for a struct containing a reflect.Value, which itself has
+                // an unexported field of type unsafe.Pointer.
+                old_safemode = safemode;
+                safemode = 0;
                 walkcompare(&n, init);
+                safemode = old_safemode;
                 goto ret;
 
         case OANDAND:
         case OOROR:
                 walkexpr(&n->left, init);
                 // cannot put side effects from n->right on init,
                 // because they cannot run before n->left is checked.
                 // save elsewhere and store on the eventual n->right.
                 ll = nil;
                 walkexpr(&n->right, &ll);
@@ skipping 609 matching lines @@
                 if((n->op == OSLICESTR && n->left->op == OLITERAL) || (n->left->op == OINDEX))
                         n->left = copyexpr(n->left, n->left->type, init);
                 else
                         n->left = safeexpr(n->left, init);
                 walkexpr(&n->right->left, init);
                 n->right->left = safeexpr(n->right->left, init);
                 walkexpr(&n->right->right, init);
                 n->right->right = safeexpr(n->right->right, init);
                 n = sliceany(n, init);  // chops n->right, sets n->list
                 goto ret;
+········
+        case OSLICE3:
+        case OSLICE3ARR:
+                if(n->right == N) // already processed
+                        goto ret;
+
+                walkexpr(&n->left, init);
+                // TODO the OINDEX case is a bug elsewhere that needs to be traced.  it causes a crash on ([2][]int{ ... })[1][lo:hi]
+                // TODO the comment on the previous line was copied from case OSLICE. it might not even be true.
+                if(n->left->op == OINDEX)
+                        n->left = copyexpr(n->left, n->left->type, init);
+                else
+                        n->left = safeexpr(n->left, init);
+                walkexpr(&n->right->left, init);
+                n->right->left = safeexpr(n->right->left, init);
+                walkexpr(&n->right->right->left, init);
+                n->right->right->left = safeexpr(n->right->right->left, init);
+                walkexpr(&n->right->right->right, init);
+                n->right->right->right = safeexpr(n->right->right->right, init);
+                n = sliceany(n, init);  // chops n->right, sets n->list
+                goto ret;
 
         case OADDR:
                 walkexpr(&n->left, init);
                 goto ret;
 
         case ONEW:
                 if(n->esc == EscNone && n->type->type->width < (1<<16)) {
                         r = temp(n->type->type);
                         r = nod(OAS, r, N);  // zero temp
                         typecheck(&r, Etop);
@@ skipping 117 matching lines @@
                 fn = syslook("makemap", 1);
                 argtype(fn, t->down);   // any-1
                 argtype(fn, t->type);   // any-2
 
                 n = mkcall1(fn, n->type, init,
                         typename(n->type),
                         conv(n->left, types[TINT64]));
                 goto ret;
 
         case OMAKESLICE:
-                // makeslice(t *Type, nel int64, max int64) (ary []any)
                 l = n->left;
                 r = n->right;
                 if(r == nil)
                         l = r = safeexpr(l, init);
                 t = n->type;
-                fn = syslook("makeslice", 1);
-                argtype(fn, t->type);                   // any-1
-                n = mkcall1(fn, n->type, init,
-                        typename(n->type),
-                        conv(l, types[TINT64]),
-                        conv(r, types[TINT64]));
+                if(n->esc == EscNone
+                        && smallintconst(l) && smallintconst(r)
+                        && mpgetfix(r->val.u.xval) < (1ULL<<16) / t->type->width) {
+                        // var arr [r]T
+                        // n = arr[:l]
+                        t = aindex(r, t->type); // [r]T
+                        var = temp(t);
+                        a = nod(OAS, var, N); // zero temp
+                        typecheck(&a, Etop);
+                        *init = list(*init, a);
+                        r = nod(OSLICE, var, nod(OKEY, N, l)); // arr[:l]
+                        r = conv(r, n->type); // in case n->type is named.
+                        typecheck(&r, Erv);
+                        walkexpr(&r, init);
+                        n = r;
+                } else {
+                        // makeslice(t *Type, nel int64, max int64) (ary []any)
+                        fn = syslook("makeslice", 1);
+                        argtype(fn, t->type);                   // any-1
+                        n = mkcall1(fn, n->type, init,
+                                typename(n->type),
+                                conv(l, types[TINT64]),
+                                conv(r, types[TINT64]));
+                }
                 goto ret;
 
         case ORUNESTR:
                 // sys_intstring(v)
                 n = mkcall("intstring", n->type, init,
                         conv(n->left, types[TINT64]));
                 goto ret;
 
         case OARRAYBYTESTR:
                 // slicebytetostring([]byte) string;
@@ skipping 60 matching lines @@
                 n = walkclosure(n, init);
                 goto ret;
 ········
         case OCALLPART:
                 n = walkpartialcall(n, init);
                 goto ret;
         }
         fatal("missing switch %O", n->op);
 
 ret:
+        // Expressions that are constant at run time but not
+        // considered const by the language spec are not turned into
+        // constants until walk. For example, if n is y%1 == 0, the
+        // walk of y%1 may have replaced it by 0.
+        // Check whether n with its updated args is itself now a constant.
+        t = n->type;
+        evconst(n);
+        n->type = t;
+        if(n->op == OLITERAL)
+                typecheck(&n, Erv);
+
         ullmancalc(n);
 
         if(debug['w'] && n != N)
                 dump("walk", n);
 
         lineno = lno;
         *np = n;
 }
 
 static Node*
@@ skipping 903 matching lines @@
         Type *t;
         Iter savet;
         Node *v;
         NodeList *nn;
 
         nn = nil;
         for(t = structfirst(&savet, argin); t != T; t = structnext(&savet)) {
                 v = t->nname;
                 if(v && v->sym && v->sym->name[0] == '~')
                         v = N;
-                if(v == N && out && hasdefer) {
+                // The garbage collector assumes results are always live,
+                // so zero them always (1 ||).
+                if(out && (1 || (v == N && hasdefer))) {
                         // Defer might stop a panic and show the
                         // return values as they exist at the time of panic.
                         // Make sure to zero them on entry to the function.
                         nn = list(nn, nod(OAS, nodarg(t, 1), N));
                 }
                 if(v == N || !(v->class & PHEAP))
                         continue;
 
                 // generate allocation & copying code
                 if(v->alloc == nil)
@@ skipping 255 matching lines @@
         nx->nbody = list1(nod(OAS, ns, mkcall1(fn,  ns->type, &nx->ninit,
                                                typename(ns->type),
                                                ns,
                                                conv(na, types[TINT64]))));
         l = list(l, nx);
 
         nn = temp(types[TINT]);
         l = list(l, nod(OAS, nn, nod(OLEN, ns, N)));     // n = len(s)
 
         nx = nod(OSLICE, ns, nod(OKEY, N, nod(OADD, nn, na)));   // ...s[:n+argc]
-        nx->bounded = 1;
+        nx->etype = 1;
         l = list(l, nod(OAS, ns, nx));                  // s = s[:n+argc]
 
         for (a = n->list->next;  a != nil; a = a->next) {
                 nx = nod(OINDEX, ns, nn);               // s[n] ...
                 nx->bounded = 1;
                 l = list(l, nod(OAS, nx, a->n));        // s[n] = arg
                 if (a->next != nil)
                         l = list(l, nod(OAS, nn, nod(OADD, nn, nodintconst(1))));  // n = n + 1
         }
 
         typechecklist(l, Etop);
         walkstmtlist(l);
         *init = concat(*init, l);
         return ns;
 }
 
 // Lower copy(a, b) to a memmove call.
 //
 // init {
 //   n := len(a)
 //   if n > len(b) { n = len(b) }
 //   memmove(a.ptr, b.ptr, n*sizeof(elem(a)))
 // }
-// l;
+// n;
 //
 // Also works if b is a string.
 //
 static Node*
 copyany(Node *n, NodeList **init)
 {
         Node *nl, *nr, *nfrm, *nto, *nif, *nlen, *nwid, *fn;
         NodeList *l;
-        Type *tp;
 
         walkexpr(&n->left, init);
         walkexpr(&n->right, init);
         nl = temp(n->left->type);
         nr = temp(n->right->type);
         l = nil;
         l = list(l, nod(OAS, nl, n->left));
         l = list(l, nod(OAS, nr, n->right));
 
-        tp = ptrto(bytetype);
-        nfrm = conv(nod(OSPTR, nr, N), tp);
-        nto = conv(nod(OSPTR, nl, N), tp);
+        nfrm = nod(OSPTR, nr, N);
+        nto = nod(OSPTR, nl, N);
 
         nlen = temp(types[TINT]);
         // n = len(to)
         l = list(l, nod(OAS, nlen, nod(OLEN, nl, N)));
         // if n > len(frm) { n = len(frm) }
         nif = nod(OIF, N, N);
         nif->ntest = nod(OGT, nlen, nod(OLEN, nr, N));
         nif->nbody = list(nif->nbody,
                 nod(OAS, nlen, nod(OLEN, nr, N)));
         l = list(l, nif);
 
         // Call memmove.
         fn = syslook("memmove", 1);
+        argtype(fn, nl->type->type);
+        argtype(fn, nl->type->type);
         nwid = temp(types[TUINTPTR]);
         l = list(l, nod(OAS, nwid, conv(nlen, types[TUINTPTR])));
         nwid = nod(OMUL, nwid, nodintconst(nl->type->type->width));
         l = list(l, mkcall1(fn, T, init, nto, nfrm, nwid));
 
         typechecklist(l, Etop);
         walkstmtlist(l);
         *init = concat(*init, l);
         return nlen;
 }
 
-// Generate frontend part for OSLICE[ARR|STR]
+// Generate frontend part for OSLICE[3][ARR|STR]
 //·
 static  Node*
 sliceany(Node* n, NodeList **init)
 {
-        int bounded;
-        Node *src, *lb, *hb, *bound, *chk, *chk1, *chk2;
-        int64 lbv, hbv, bv, w;
+        int bounded, slice3;
+        Node *src, *lb, *hb, *cb, *bound, *chk, *chk0, *chk1, *chk2;
+        int64 lbv, hbv, cbv, bv, w;
         Type *bt;
 
 //      print("before sliceany: %+N\n", n);
 
         src = n->left;
         lb = n->right->left;
-        hb = n->right->right;
+        slice3 = n->op == OSLICE3 || n->op == OSLICE3ARR;
+        if(slice3) {
+                hb = n->right->right->left;
+                cb = n->right->right->right;
+        } else {
+                hb = n->right->right;
+                cb = N;
+        }
 
         bounded = n->etype;
 ········
         if(n->op == OSLICESTR)
                 bound = nod(OLEN, src, N);
         else
                 bound = nod(OCAP, src, N);
 
         typecheck(&bound, Erv);
         walkexpr(&bound, init);  // if src is an array, bound will be a const now.
 
         // static checks if possible
         bv = 1LL<<50;
         if(isconst(bound, CTINT)) {
                 if(!smallintconst(bound))
                         yyerror("array len too large");
                 else
                         bv = mpgetfix(bound->val.u.xval);
         }
 
+        if(isconst(cb, CTINT)) {
+                cbv = mpgetfix(cb->val.u.xval);
+                if(cbv < 0 || cbv > bv) {
+                        yyerror("slice index out of bounds");
+                        cbv = -1;
+                }
+        }
         if(isconst(hb, CTINT)) {
                 hbv = mpgetfix(hb->val.u.xval);
                 if(hbv < 0 || hbv > bv) {
                         yyerror("slice index out of bounds");
                         hbv = -1;
                 }
         }
         if(isconst(lb, CTINT)) {
                 lbv = mpgetfix(lb->val.u.xval);
                 if(lbv < 0 || lbv > bv) {
                         yyerror("slice index out of bounds");
                         lbv = -1;
                 }
                 if(lbv == 0)
                         lb = N;
         }
 
         // dynamic checks convert all bounds to unsigned to save us the bound < 0 comparison
         // generate
         //     if hb > bound || lb > hb { panicslice() }
         chk = N;
+        chk0 = N;
         chk1 = N;
         chk2 = N;
 
         bt = types[simtype[TUINT]];
+        if(cb != N && cb->type->width > 4)
+                bt = types[TUINT64];
         if(hb != N && hb->type->width > 4)
                 bt = types[TUINT64];
         if(lb != N && lb->type->width > 4)
                 bt = types[TUINT64];
 
         bound = cheapexpr(conv(bound, bt), init);
 
+        if(cb != N) {
+                cb = cheapexpr(conv(cb, bt), init);
+                if(!bounded)
+                        chk0 = nod(OLT, bound, cb);
+        } else if(slice3) {
+                // When we figure out what this means, implement it.
+                fatal("slice3 with cb == N"); // rejected by parser
+        }
+················
         if(hb != N) {
                 hb = cheapexpr(conv(hb, bt), init);
-                if(!bounded)
-                        chk1 = nod(OLT, bound, hb);··
+                if(!bounded) {
+                        if(cb != N)
+                                chk1 = nod(OLT, cb, hb);
+                        else
+                                chk1 = nod(OLT, bound, hb);
+                }
+        } else if(slice3) {
+                // When we figure out what this means, implement it.
+                fatal("slice3 with hb == N"); // rejected by parser
         } else if(n->op == OSLICEARR) {
                 hb = bound;
         } else {
                 hb = nod(OLEN, src, N);
                 typecheck(&hb, Erv);
                 walkexpr(&hb, init);
                 hb = cheapexpr(conv(hb, bt), init);
         }
 
         if(lb != N) {
                 lb = cheapexpr(conv(lb, bt), init);
                 if(!bounded)
                         chk2 = nod(OLT, hb, lb);··
         }
 
-        if(chk1 != N || chk2 != N) {
+        if(chk0 != N || chk1 != N || chk2 != N) {
                 chk = nod(OIF, N, N);
                 chk->nbody = list1(mkcall("panicslice", T, init));
-                if(chk1 != N)
-                        chk->ntest = chk1;
+                chk->likely = -1;
+                if(chk0 != N)
+                        chk->ntest = chk0;
+                if(chk1 != N) {
+                        if(chk->ntest == N)
+                                chk->ntest = chk1;
+                        else
+                                chk->ntest = nod(OOROR, chk->ntest, chk1);
+                }
                 if(chk2 != N) {
                         if(chk->ntest == N)
                                 chk->ntest = chk2;
                         else
                                 chk->ntest = nod(OOROR, chk->ntest, chk2);
                 }
                 typecheck(&chk, Etop);
                 walkstmt(&chk);
                 *init = concat(*init, chk->ninit);
                 chk->ninit = nil;
                 *init = list(*init, chk);
         }
 ········
         // prepare new cap, len and offs for backend cgen_slice
         // cap = bound [ - lo ]
         n->right = N;
         n->list = nil;
+        if(!slice3)
+                cb = bound;
         if(lb == N)
-                bound = conv(bound, types[simtype[TUINT]]);
+                bound = conv(cb, types[simtype[TUINT]]);
         else
-                bound = nod(OSUB, conv(bound, types[simtype[TUINT]]), conv(lb, types[simtype[TUINT]]));
+                bound = nod(OSUB, conv(cb, types[simtype[TUINT]]), conv(lb, types[simtype[TUINT]]));
         typecheck(&bound, Erv);
         walkexpr(&bound, init);
         n->list = list(n->list, bound);
 
         // len = hi [ - lo]
         if(lb == N)
                 hb = conv(hb, types[simtype[TUINT]]);
         else
                 hb = nod(OSUB, conv(hb, types[simtype[TUINT]]), conv(lb, types[simtype[TUINT]]));
         typecheck(&hb, Erv);
@@ skipping 809 matching lines @@
            !candiscardlist(n->ninit) ||
            !candiscardlist(n->nbody) ||
            !candiscardlist(n->nelse) ||
            !candiscardlist(n->list) ||
            !candiscardlist(n->rlist)) {
                 return 0;
         }
 ········
         return 1;
 }