code review 6845113: cmd/gc: Error out on division by constant zero.

src/cmd/gc/typecheck.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.
 
 /*
  * type check the whole tree of an expression.
  * calculates expression types.
  * evaluates compile time constants.
  * marks variables that escape the local frame.
  * rewrites n->op to be more specific in some cases.
@@ skipping 464 matching lines @@
                 l = typecheck(&n->left, ntop);
                 if((t = l->type) == T)
                         goto error;
                 if(l->op == OTYPE) {
                         ok |= Etype;
                         n->op = OTYPE;
                         n->type = ptrto(l->type);
                         n->left = N;
                         goto ret;
                 }
-                if((top & (Erv | Etop)) && !isptr[t->etype]) {
-                        yyerror("invalid indirect of %lN", n->left);
-                        goto error;
+                if(!isptr[t->etype]) {
+                        if(top & (Erv | Etop)) {
+                                yyerror("invalid indirect of %lN", n->left);
+                                goto error;
+                        }
+                        goto ret;
                 }
                 ok |= Erv;
                 n->type = t->type;
                 goto ret;
 
         /*
          * arithmetic exprs
          */
         case OASOP:
                 ok |= Etop;
@@ skipping 132 matching lines @@
                                 // swap for back end
                                 n->left = r;
                                 n->right = l;
                         } else if(r->op == OLITERAL && r->val.ctype == CTNIL) {
                                 // leave alone for back end
                         } else {
                                 n->etype = n->op;
                                 n->op = OCMPIFACE;
                         }
                 }
-                if((op == ODIV || op == OMOD) && r->op == OLITERAL) {
-                        switch(r->val.ctype) {
-                        case CTINT:
-                        case CTRUNE:
-                                if(mpcmpfixc(r->val.u.xval, 0) == 0) {
-                                        yyerror("division by zero");
-                                        goto error;
-                                }
-                                break;
-                        case CTFLT:
-                                if(mpcmpfltc(r->val.u.fval, 0) == 0) {
-                                        yyerror("division by zero");
-                                        goto error;
-                                }
-                                break;
-                        case CTCPLX:
-                                if(mpcmpfltc(&r->val.u.cval->real, 0) == 0 &&
-                                   mpcmpfltc(&r->val.u.cval->imag, 0) == 0) {
-                                        yyerror("complex division by zero");
-                                        goto error;
-                                }
-                                break;
-                        }
+
+                if((op == ODIV || op == OMOD) && isconst(r, CTINT))
+                if(mpcmpfixc(r->val.u.xval, 0) == 0) {
+                        yyerror("division by zero");
+                        goto error;
                 }·
+
                 n->type = t;
                 goto ret;
 
         shift:
                 defaultlit(&r, types[TUINT]);
                 n->right = r;
                 t = r->type;
                 if(!isint[t->etype] || issigned[t->etype]) {
                         yyerror("invalid operation: %N (shift count type %T, must be unsigned integer)", n, r->type);
                         goto error;
@@ skipping 293 matching lines @@
                         goto error;
                 }
                 if(n->right->left != N) {
                         if((t = n->right->left->type) == T)
                                 goto error;
                         if(!isint[t->etype]) {
                                 yyerror("invalid slice index %N (type %T)", n->right->left, t);
                                 goto error;
                         }
                         if(n->right->left->op == OLITERAL) {
-                                if(mpgetfix(n->right->left->val.u.xval) < 0)
+                                if(mpgetfix(n->right->left->val.u.xval) < 0) {
                                         yyerror("invalid slice index %N (index must be non-negative)", n->right->left);
-                                else if(tp != nil && tp->bound > 0 && mpgetfix(n->right->left->val.u.xval) > tp->bound)
+                                        goto error;
+                                } else if(tp != nil && tp->bound > 0 && mpgetfix(n->right->left->val.u.xval) > tp->bound) {
                                         yyerror("invalid slice index %N (out of bounds for %d-element array)", n->right->left, tp->bound);
-                                else if(mpcmpfixfix(n->right->left->val.u.xval, maxintval[TINT]) > 0)
+                                        goto error;
+                                } else if(mpcmpfixfix(n->right->left->val.u.xval, maxintval[TINT]) > 0) {
                                         yyerror("invalid slice index %N (index too large)", n->right->left);
+                                        goto error;
+                                }
                         }
                 }
                 if(n->right->right != N) {
                         if((t = n->right->right->type) == T)
                                 goto error;
                         if(!isint[t->etype]) {
                                 yyerror("invalid slice index %N (type %T)", n->right->right, t);
                                 goto error;
                         }
                         if(n->right->right->op == OLITERAL) {
-                                if(mpgetfix(n->right->right->val.u.xval) < 0)
+                                if(mpgetfix(n->right->right->val.u.xval) < 0) {
                                         yyerror("invalid slice index %N (index must be non-negative)", n->right->right);
-                                else if(tp != nil && tp->bound > 0 && mpgetfix(n->right->right->val.u.xval) > tp->bound)
+                                        goto error;
+                                } else if(tp != nil && tp->bound > 0 && mpgetfix(n->right->right->val.u.xval) > tp->bound) {
                                         yyerror("invalid slice index %N (out of bounds for %d-element array)", n->right->right, tp->bound);
-                                else if(mpcmpfixfix(n->right->right->val.u.xval, maxintval[TINT]) > 0)
+                                        goto error;
+                                } else if(mpcmpfixfix(n->right->right->val.u.xval, maxintval[TINT]) > 0) {
                                         yyerror("invalid slice index %N (index too large)", n->right->right);
-                        }
+                                        goto error;
+                                }
+                        }
+                }
+                if(n->right->left != N
+                   && n->right->right != N
+                   && n->right->left->op == OLITERAL
+                   && n->right->right->op == OLITERAL
+                   && mpcmpfixfix(n->right->left->val.u.xval, n->right->right->val.u.xval) > 0) {
+                        yyerror("inverted slice index %N > %N", n->right->left, n->right->right);
+                        goto error;
                 }
                 goto ret;
 
         /*
          * call and call like
          */
         case OCALL:
                 l = n->left;
                 if(l->op == ONAME && (r = unsafenmagic(n)) != N) {
                         if(n->isddd)
@@ skipping 772 matching lines @@
                         break;
                 }
                 r = f;
         }
         return r;
 }
 
 static int
 looktypedot(Node *n, Type *t, int dostrcmp)
 {
-        Type *f1, *f2, *tt;
+        Type *f1, *f2;
         Sym *s;
 ········
         s = n->right->sym;
 
         if(t->etype == TINTER) {
                 f1 = lookdot1(n, s, t, t->type, dostrcmp);
                 if(f1 == T)
                         return 0;
 
-                if(f1->width == BADWIDTH)
-                        fatal("lookdot badwidth %T %p", f1, f1);
                 n->right = methodname(n->right, t);
                 n->xoffset = f1->width;
                 n->type = f1->type;
                 n->op = ODOTINTER;
                 return 1;
         }
 
-        tt = t;
-        if(t->sym == S && isptr[t->etype])
-                tt = t->type;
-
-        f2 = methtype(tt, 0);
+        // Find the base type: methtype will fail if t
+        // is not of the form T or *T.
+        f2 = methtype(t, 0);
         if(f2 == T)
                 return 0;
 
         expandmeth(f2);
         f2 = lookdot1(n, s, f2, f2->xmethod, dostrcmp);
         if(f2 == T)
                 return 0;
 
         // disallow T.m if m requires *T receiver
         if(isptr[getthisx(f2->type)->type->type->etype]
@@ skipping 1189 matching lines @@
                 fatal("got %T for %N", n->type, n);
         if(typecheckdefstack->n != n)
                 fatal("typecheckdefstack mismatch");
         l = typecheckdefstack;
         typecheckdefstack = l->next;
 
         lineno = lno;
         n->walkdef = 1;
         return n;
 }