code review 7461046: all: fix typos

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 <u.h>
 #include <libc.h>
 #include "gg.h"
 
 /*
  * generate:
@@ skipping 550 matching lines @@
  * allocate a register in res and generate
  * res = &n
  */
 void
 agenr(Node *n, Node *a, Node *res)
 {
         Node *nl, *nr;
         Node n1, n2, n3, n4, n5, tmp, tmp2, nlen;
         Prog *p1;
         Type *t;
-        uint32 w;
+        uint64 w;
         uint64 v;
         int freelen;
 
         if(debug['g']) {
                 dump("\nagenr-n", n);
         }
 
         nl = n->left;
         nr = n->right;
 
@@ skipping 293 matching lines @@
                 if(n->xoffset != 0)
                         ginscon(optoas(OADD, types[tptr]), n->xoffset, res);
                 break;
 
         case OIND:
                 cgen(nl, res);
                 break;
 
         case ODOT:
                 agen(nl, res);
+                // explicit check for nil if struct is large enough
+                // that we might derive too big a pointer.  If the left node
+                // was ODOT we have already done the nil check.
+                if(nl->op != ODOT)
+                if(nl->type->width >= unmappedzero) {
+                        regalloc(&n1, types[tptr], res);
+                        gmove(res, &n1);
+                        n1.op = OINDREG;
+                        n1.type = types[TUINT8];
+                        n1.xoffset = 0;
+                        gins(ATESTB, nodintconst(0), &n1);
+                        regfree(&n1);
+                }
                 if(n->xoffset != 0)
                         ginscon(optoas(OADD, types[tptr]), n->xoffset, res);
                 break;
 
         case ODOTPTR:
                 cgen(nl, res);
+                // explicit check for nil if struct is large enough
+                // that we might derive too big a pointer.
+                if(nl->type->type->width >= unmappedzero) {
+                        regalloc(&n1, types[tptr], res);
+                        gmove(res, &n1);
+                        n1.op = OINDREG;
+                        n1.type = types[TUINT8];
+                        n1.xoffset = 0;
+                        gins(ATESTB, nodintconst(0), &n1);
+                        regfree(&n1);
+                }
                 if(n->xoffset != 0) {
-                        // explicit check for nil if struct is large enough
-                        // that we might derive too big a pointer.
-                        if(nl->type->type->width >= unmappedzero) {
-                                regalloc(&n1, types[tptr], res);
-                                gmove(res, &n1);
-                                n1.op = OINDREG;
-                                n1.type = types[TUINT8];
-                                n1.xoffset = 0;
-                                gins(ATESTB, nodintconst(0), &n1);
-                                regfree(&n1);
-                        }
                         ginscon(optoas(OADD, types[tptr]), n->xoffset, res);
                 }
                 break;
         }
 
 ret:
         ;
 }
 
 /*
@@ skipping 30 matching lines @@
                 return;
 
         case ODOT:
                 igen(n->left, a, res);
                 a->xoffset += n->xoffset;
                 a->type = n->type;
                 return;
 
         case ODOTPTR:
                 cgenr(n->left, a, res);
-                if(n->xoffset != 0) {
-                        // explicit check for nil if struct is large enough
-                        // that we might derive too big a pointer.
-                        if(n->left->type->type->width >= unmappedzero) {
-                                n1 = *a;
-                                n1.op = OINDREG;
-                                n1.type = types[TUINT8];
-                                n1.xoffset = 0;
-                                gins(ATESTB, nodintconst(0), &n1);
-                        }
+                // explicit check for nil if struct is large enough
+                // that we might derive too big a pointer.
+                if(n->left->type->type->width >= unmappedzero) {
+                        n1 = *a;
+                        n1.op = OINDREG;
+                        n1.type = types[TUINT8];
+                        n1.xoffset = 0;
+                        gins(ATESTB, nodintconst(0), &n1);
                 }
                 a->op = OINDREG;
                 a->xoffset += n->xoffset;
                 a->type = n->type;
                 return;
 
         case OCALLFUNC:
         case OCALLMETH:
         case OCALLINTER:
                 switch(n->op) {
@@ skipping 296 matching lines @@
 
 ret:
         ;
 }
 
 /*
  * n is on stack, either local variable
  * or return value from function call.
  * return n's offset from SP.
  */
-int32
+int64
 stkof(Node *n)
 {
         Type *t;
         Iter flist;
-        int32 off;
+        int64 off;
 
         switch(n->op) {
         case OINDREG:
                 return n->xoffset;
 
         case ODOT:
                 t = n->left->type;
                 if(isptr[t->etype])
                         break;
                 off = stkof(n->left);
@@ skipping 369 matching lines @@
                 regfree(&nodl);
         return 0;
 
 yes:
         if(freer)
                 regfree(&nodr);
         if(freel)
                 regfree(&nodl);
         return 1;
 }