code review 91850043: cmd/gc: alias more variables during register allocation

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 811 matching lines @@
 ········
         base = temp(types[TUINTPTR]);
 
         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;
-        src.type = types[TUINTPTR];
 
         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) {
+                src.type = types[tptr];
                 cgen(&src, base);
         } else {
-                add = nod(OADD, &src, offs);
+                src.type = types[tptr];
+                add = nod(OADDPTR, &src, offs);
                 typecheck(&add, Erv);
                 cgen(add, base);
         }
 ········
         // committed to the update
         gvardef(res);
 
         // dst.array = src.array  [ + lo *width ]
         dst = *res;
         dst.xoffset += Array_array;
-        dst.type = types[TUINTPTR];
+        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);
 
         if(n->op != OSLICESTR) {
@@ skipping 93 matching lines @@
 Node*
 temp(Type *t)
 {
         Node *n;
 ········
         n = nod(OXXX, N, N);
         tempname(n, t);
         n->sym->def->used = 1;
         return n->orig;
 }