[dev.power64] code review 160200044: build: merge default into dev.power64

src/cmd/gc/gen.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.
 
 /*
  * portable half of code generator.
  * mainly statements and control flow.
  */
 
 #include <u.h>
@@ skipping 788 matching lines @@
  *      res = s[lo, hi];
  * n->left is s
  * n->list is (cap(s)-lo(TUINT), hi-lo(TUINT)[, lo*width(TUINTPTR)])
  * caller (cgen) guarantees res is an addable ONAME.
  *
  * called for OSLICE, OSLICE3, OSLICEARR, OSLICE3ARR, OSLICESTR.
  */
 void
 cgen_slice(Node *n, Node *res)
 {
-        Node src, dst, *cap, *len, *offs, *add, *base;
+        Node src, dst, *cap, *len, *offs, *add, *base, *tmpcap, *tmplen, *cmp, con;
+        Prog *p1, *p2;
 
         cap = n->list->n;
         len = n->list->next->n;
         offs = N;
         if(n->list->next->next)
                 offs = n->list->next->next->n;
 
         // evaluate base pointer first, because it is the only
         // possibly complex expression. once that is evaluated
         // and stored, updating the len and cap can be done
         // without making any calls, so without doing anything that
         // might cause preemption or garbage collection.
         // this makes the whole slice update atomic as far as the
         // garbage collector can see.
 ········
         base = temp(types[TUINTPTR]);
+        tmplen = temp(types[TINT]);
+        if(n->op != OSLICESTR)
+                tmpcap = temp(types[TINT]);
+        else
+                tmpcap = tmplen;
 
         if(isnil(n->left)) {
                 tempname(&src, n->left->type);
                 cgen(n->left, &src);
         } else
                 src = *n->left;
         if(n->op == OSLICE || n->op == OSLICE3 || n->op == OSLICESTR)
                 src.xoffset += Array_array;
 
         if(n->op == OSLICEARR || n->op == OSLICE3ARR) {
                 if(!isptr[n->left->type->etype])
                         fatal("slicearr is supposed to work on pointer: %+N\n", n);
                 cgen(&src, base);
                 cgen_checknil(base);
-                if(offs != N) {
-                        add = nod(OADD, base, offs);
-                        typecheck(&add, Erv);
-                        cgen(add, base);
-                }
-        } else if(offs == N) {
+        } else {
                 src.type = types[tptr];
                 cgen(&src, base);
-        } else {
-                src.type = types[tptr];
-                add = nod(OADDPTR, &src, offs);
-                typecheck(&add, Erv);
-                cgen(add, base);
         }
 ········
         // committed to the update
         gvardef(res);
 
+        // compute len and cap.
+        // len = n-i, cap = m-i, and offs = i*width.
+        // computing offs last lets the multiply overwrite i.
+        cgen(len, tmplen);
+        if(n->op != OSLICESTR)
+                cgen(cap, tmpcap);
+
+        // if new cap != 0 { base += add }
+        // This avoids advancing base past the end of the underlying array/string,
+        // so that it cannot point at the next object in memory.
+        // If cap == 0, the base doesn't matter except insofar as it is 0 or non-zero.
+        // In essence we are replacing x[i:j:k] where i == j == k
+        // or x[i:j] where i == j == cap(x) with x[0:0:0].
+        if(offs != N) {
+                p1 = gjmp(P);
+                p2 = gjmp(P);
+                patch(p1, pc);
+
+                nodconst(&con, tmpcap->type, 0);
+                cmp = nod(OEQ, tmpcap, &con);
+                typecheck(&cmp, Erv);
+                bgen(cmp, 1, -1, p2);
+
+                add = nod(OADD, base, offs);
+                typecheck(&add, Erv);
+                cgen(add, base);
+
+                patch(p2, pc);
+        }
+
         // dst.array = src.array  [ + lo *width ]
         dst = *res;
         dst.xoffset += Array_array;
         dst.type = types[tptr];
-········
         cgen(base, &dst);
 
         // dst.len = hi [ - lo ]
         dst = *res;
         dst.xoffset += Array_nel;
         dst.type = types[simtype[TUINT]];
-        cgen(len, &dst);
+        cgen(tmplen, &dst);
 
         if(n->op != OSLICESTR) {
                 // dst.cap = cap [ - lo ]
                 dst = *res;
                 dst.xoffset += Array_cap;
                 dst.type = types[simtype[TUINT]];
-                cgen(cap, &dst);
+                cgen(tmpcap, &dst);
         }
 }
 
 /*
  * gather series of offsets
  * >=0 is direct addressed field
  * <0 is pointer to next field (+1)
  */
 int
 dotoffset(Node *n, int64 *oary, Node **nn)
@@ skipping 78 matching lines @@
 Node*
 temp(Type *t)
 {
         Node *n;
 ········
         n = nod(OXXX, N, N);
         tempname(n, t);
         n->sym->def->used = 1;
         return n->orig;
 }