code review 7142052: cmd/gc: don't hash nor compare struct padding or blank ...

src/cmd/gc/subr.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        "go.h"
 #include        "md5.h"
 #include        "y.tab.h"
 #include        "yerr.h"
@@ skipping 486 matching lines @@
         n->op = op;
         n->left = nleft;
         n->right = nright;
         n->lineno = parserline();
         n->xoffset = BADWIDTH;
         n->orig = n;
         n->curfn = curfn;
         return n;
 }
 
+static int
+ispaddedfield(Type *t)
+{
+        if(t->etype != TFIELD)
+                fatal("ispaddedfield called non-field %T", t);
+        return t->down != T && t->width + t->type->width != t->down->width;
+}
+
 int
 algtype1(Type *t, Type **bad)
 {
         int a, ret;
         Type *t1;
 ········
         if(bad)
                 *bad = T;
 
         switch(t->etype) {
@@ skipping 57 matching lines @@
                 }
                 return -1;  // needs special compare
 
         case TSTRUCT:
                 if(t->type != T && t->type->down == T) {
                         // One-field struct is same as that one field alone.
                         return algtype1(t->type->type, bad);
                 }
                 ret = AMEM;
                 for(t1=t->type; t1!=T; t1=t1->down) {
-                        if(isblanksym(t1->sym))
+                        // Blank fields and padding must be ignored,
+                        // so need special compare.
+                        if(isblanksym(t1->sym) || ispaddedfield(t1)) {
+                                ret = -1;
                                 continue;
+                        }
                         a = algtype1(t1->type, bad);
                         if(a == ANOEQ)
                                 return ANOEQ;  // not comparable
                         if(a != AMEM)
                                 ret = -1;  // needs special compare
                 }
                 return ret;
         }
 
         fatal("algtype1: unexpected type %T", t);
@@ skipping 2091 matching lines @@
                 n->nbody = list(n->nbody, call);
 
                 fn->nbody = list(fn->nbody, n);
                 break;
 
         case TSTRUCT:
                 // Walk the struct using memhash for runs of AMEM
                 // and calling specific hash functions for the others.
                 first = T;
                 for(t1=t->type;; t1=t1->down) {
-                        if(t1 != T && (isblanksym(t1->sym) || algtype1(t1->type, nil) == AMEM)) {
-                                if(first == T && !isblanksym(t1->sym))
+                        if(t1 != T && algtype1(t1->type, nil) == AMEM && !isblanksym(t1->sym)) {
+                                if(first == T)
                                         first = t1;
-                                continue;
+                                // If it's a memory field but it's padded, stop here.
+                                if(ispaddedfield(t1))
+                                        t1 = t1->down;
+                                else
+                                        continue;
                         }
                         // Run memhash for fields up to this one.
-                        while(first != T && isblanksym(first->sym))
-                                first = first->down;
                         if(first != T) {
                                 if(first->down == t1)
                                         size = first->type->width;
                                 else if(t1 == T)
                                         size = t->width - first->width;  // first->width is offset
                                 else
                                         size = t1->width - first->width;  // both are offsets
                                 hashel = hashmem(first->type);
                                 // hashel(h, size, &p.first)
                                 call = nod(OCALL, hashel, N);
                                 call->list = list(call->list, nh);
                                 call->list = list(call->list, nodintconst(size));
                                 nx = nod(OXDOT, np, newname(first->sym));  // TODO: fields from other packages?
                                 na = nod(OADDR, nx, N);
                                 na->etype = 1;  // no escape to heap
                                 call->list = list(call->list, na);
                                 fn->nbody = list(fn->nbody, call);
 
                                 first = T;
                         }
                         if(t1 == T)
                                 break;
+                        if(isblanksym(t1->sym))
+                                continue;
 
                         // Run hash for this field.
                         hashel = hashfor(t1->type);
                         // hashel(h, size, &p.t1)
                         call = nod(OCALL, hashel, N);
                         call->list = list(call->list, nh);
                         call->list = list(call->list, nodintconst(t1->type->width));
                         nx = nod(OXDOT, np, newname(t1->sym));  // TODO: fields from other packages?
                         na = nod(OADDR, nx, N);
                         na->etype = 1;  // no escape to heap
                         call->list = list(call->list, na);
                         fn->nbody = list(fn->nbody, call);
                 }
+                // make sure body is not empty.
+                fn->nbody = list(fn->nbody, nod(ORETURN, N, N));
                 break;
         }
 
         if(debug['r'])
                 dumplist("genhash body", fn->nbody);
 
         funcbody(fn);
         curfn = fn;
         fn->dupok = 1;
         typecheck(&fn, Etop);
@@ skipping 152 matching lines @@
                 nrange->nbody = list(nrange->nbody, nif);
                 fn->nbody = list(fn->nbody, nrange);
 
                 // *eq = true;
                 fn->nbody = list(fn->nbody, nod(OAS, nod(OIND, neq, N), nodbool(1)));
                 break;
 
         case TSTRUCT:
                 // Walk the struct using memequal for runs of AMEM
                 // and calling specific equality tests for the others.
+                // Skip blank-named fields.
                 first = T;
                 for(t1=t->type;; t1=t1->down) {
-                        if(t1 != T && (isblanksym(t1->sym) || algtype1(t1->type, nil) == AMEM)) {
-                                if(first == T && !isblanksym(t1->sym))
+                        if(t1 != T && algtype1(t1->type, nil) == AMEM && !isblanksym(t1->sym)) {
+                                if(first == T)
                                         first = t1;
-                                continue;
+                                // If it's a memory field but it's padded, stop here.
+                                if(ispaddedfield(t1))
+                                        t1 = t1->down;
+                                else
+                                        continue;
                         }
                         // Run memequal for fields up to this one.
                         // TODO(rsc): All the calls to newname are wrong for
                         // cross-package unexported fields.
-                        while(first != T && isblanksym(first->sym))
-                                first = first->down;
                         if(first != T) {
                                 if(first->down == t1) {
                                         fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym), neq));
                                 } else if(first->down->down == t1) {
                                         fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym), neq));
                                         first = first->down;
                                         if(!isblanksym(first->sym))
                                                 fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym), neq));
                                 } else {
                                         // More than two fields: use memequal.
                                         if(t1 == T)
                                                 size = t->width - first->width;  // first->width is offset
                                         else
                                                 size = t1->width - first->width;  // both are offsets
                                         fn->nbody = list(fn->nbody, eqmem(np, nq, newname(first->sym), size, neq));
                                 }
                                 first = T;
                         }
                         if(t1 == T)
                                 break;
+                        if(isblanksym(t1->sym))
+                                continue;
 
                         // Check this field, which is not just memory.
                         fn->nbody = list(fn->nbody, eqfield(np, nq, newname(t1->sym), neq));
                 }
 
                 // *eq = true;
                 fn->nbody = list(fn->nbody, nod(OAS, nod(OIND, neq, N), nodbool(1)));
                 break;
         }
 
@@ skipping 716 matching lines @@
                         yyerror("import path contains space character: \"%Z\"", path);
                         return 1;
                 }
                 if(utfrune("!\"#$%&'()*,:;<=>?[]^`{|}", r)) {
                         yyerror("import path contains invalid character '%C': \"%Z\"", r, path);
                         return 1;
                 }
         }
         return 0;
 }