code review 1848056: gc: index bounds tests and fixes

src/cmd/6g/cgen.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 "gg.h"
 
 /*
  * generate:
  *      res = n;
  * simplifies and calls gmove.
@@ skipping 400 matching lines @@
 }
 
 /*
  * generate:
  *      res = &n;
  */
 void
 agen(Node *n, Node *res)
 {
         Node *nl, *nr;
-        Node n1, n2, n3, tmp, n4;
+        Node n1, n2, n3, tmp, n4, n5;
         Prog *p1;
         uint32 w;
         uint64 v;
         Type *t;
 
         if(debug['g']) {
                 dump("\nagen-res", res);
                 dump("agen-r", n);
         }
         if(n == N || n->type == T)
@@ skipping 79 matching lines @@
                         regfree(&n4);
                 }
 
                 if(w == 0)
                         fatal("index is zero width");
 
                 // constant index
                 if(isconst(nr, CTINT)) {
                         v = mpgetfix(nr->val.u.xval);
                         if(isslice(nl->type)) {
-
                                 if(!debug['B'] && !n->etype) {
                                         n1 = n3;
                                         n1.op = OINDREG;
                                         n1.type = types[tptr];
                                         n1.xoffset = Array_nel;
-                                        nodconst(&n2, types[TUINT64], v);
+                                        nodconst(&n2, types[TUINT32], v);
                                         gins(optoas(OCMP, types[TUINT32]), &n1, &n2);
                                         p1 = gbranch(optoas(OGT, types[TUINT32]), T);
                                         ginscall(panicindex, 0);
                                         patch(p1, pc);
                                 }
 
                                 n1 = n3;
                                 n1.op = OINDREG;
                                 n1.type = types[tptr];
                                 n1.xoffset = Array_array;
                                 gmove(&n1, &n3);
-                        } else
-                        if(!debug['B'] && !n->etype) {
-                                if(v < 0)
-                                        yyerror("out of bounds on array");
-                                else
-                                if(v >= nl->type->bound)
-                                        yyerror("out of bounds on array");
                         }
 
                         nodconst(&n2, types[tptr], v*w);
                         gins(optoas(OADD, types[tptr]), &n2, &n3);
 
                         gmove(&n3, res);
                         regfree(&n3);
                         break;
                 }
 
                 // type of the index
                 t = types[TUINT64];
                 if(issigned[n1.type->etype])
                         t = types[TINT64];
 
                 regalloc(&n2, t, &n1);                  // i
                 gmove(&n1, &n2);
                 regfree(&n1);
 
                 if(!debug['B'] && !n->etype) {
                         // check bounds
+                        n5.op = OXXX;
+                        t = types[TUINT32];
                         if(isslice(nl->type)) {
                                 n1 = n3;
                                 n1.op = OINDREG;
-                                n1.type = types[tptr];
+                                n1.type = types[TUINT32];
                                 n1.xoffset = Array_nel;
-                        } else
-                                nodconst(&n1, types[TUINT64], nl->type->bound);
-                        gins(optoas(OCMP, types[TUINT32]), &n2, &n1);
-                        p1 = gbranch(optoas(OLT, types[TUINT32]), T);
+                                if(is64(nr->type)) {
+                                        t = types[TUINT64];
+                                        regalloc(&n5, t, N);
+                                        gmove(&n1, &n5);
+                                        n1 = n5;
+                                }
+                        } else {
+                                if(is64(nr->type))
+                                        t = types[TUINT64];
+                                nodconst(&n1, t, nl->type->bound);
+                        }
+                        gins(optoas(OCMP, t), &n2, &n1);
+                        p1 = gbranch(optoas(OLT, t), T);
+                        if(n5.op != OXXX)
+                                regfree(&n5);
                         ginscall(panicindex, 0);
                         patch(p1, pc);
                 }
 
                 if(isslice(nl->type)) {
                         n1 = n3;
                         n1.op = OINDREG;
                         n1.type = types[tptr];
                         n1.xoffset = Array_array;
                         gmove(&n1, &n3);
@@ skipping 506 matching lines @@
                         gins(AMOVSB, N, N);     // MOVB *(SI)+,*(DI)+
                         c--;
                 }
         }
 
 
         restx(&nodl, &oldl);
         restx(&nodr, &oldr);
         restx(&cx, &oldcx);
 }