code review 5966075: cmd/gc: inline slice[arr,str] in the frontend (mostly).

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 886 matching lines @@
                 if (n->right != N && n->right->left == N && n->right->right == N) { // noop
                         walkexpr(&n->left, init);
                         n = n->left;
                         goto ret;
                 }
                 // fallthrough
         case OSLICEARR:
         case OSLICESTR:
                 if(n->right) {
                         walkexpr(&n->left, init);
-                        n->left = copyexpr(n->left, n->left->type, init);
+                        // cgen_slice can't handle string literals as source
+                        // TODO the OINDEX case is a bug elsewhere that needs to be traced.  it causes a crash on ([2][]int{ ... })[1][lo:hi]
+                        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 OADDR:
@@ skipping 1414 matching lines @@
         Node *src, *lb, *hb, *bound, *chk, *chk1, *chk2;
         int64 lbv, hbv, bv, w;
         Type *bt;
 
 //      print("before sliceany: %+N\n", n);
 
         src = n->left;
         lb = n->right->left;
         hb = n->right->right;
 
         nochk = n->etype;

[rsc, 2012/06/02 22:47:58]

This is now n->bounded.

 ········
         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 << 31) - 1;  // TODO this is to satisfy the unittest, which tests with 1<<31 as smallest invalid
         if (isconst(bound, CTINT))

[rsc, 2012/06/02 22:47:58]

All these isconst need to check the range of the value too. There can be very
large integer constants that won't fit in the int64s here.

                 bv = mpgetfix(bound->val.u.xval);
         lbv = -1;
         hbv = -1;
 
         if(isconst(hb, CTINT)) {
                 hbv = mpgetfix(hb->val.u.xval);
                 if(hbv < 0 || hbv > bv) {
                         yyerror("slice index out of bounds");
                         hbv = -1;
                 }
@@ skipping 23 matching lines @@
         if(lb != N && lb->type->width > 4)
                 bt = types[TUINT64];
 
         bound = cheapexpr(conv(bound, bt), init);
 
         if(hb != N) {
                 hb = cheapexpr(conv(hb, bt), init);
                 if(!nochk)
                         chk1 = nod(OLT, bound, hb);··
         } else {
                 if(n->op == OSLICE) {

[rsc, 2012/06/02 22:47:58]

I think OSLICESTR should be here too.

                         hb = nod(OLEN, src, N);
                         typecheck(&hb, Erv);
                         walkexpr(&hb, init);
                         hb = cheapexpr(conv(hb, bt), init);
                 } else
                         hb = bound;
         }
 
 
         if(lb != N) {
@@ skipping 237 matching lines @@
         argtype(fn, n->left->type);
         argtype(fn, n->left->type);
         r = mkcall1(fn, n->type, init, typename(n->left->type), l, r);
         if(n->op == ONE) {
                 r = nod(ONOT, r, N);
                 typecheck(&r, Erv);
         }
         *np = r;
         return;
 }