code review 180059: Use BitSize instead of the field's type native ByteSize...

src/cmd/cgo/gcc.go

 // 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.
 
 // Annotate Crefs in Prog with C types by parsing gcc debug output.
 // Conversion of debug output to Go types.
 
 package main
 
 import (
@@ skipping 674 matching lines @@
                         // Also avoid existing fields
                         for _, exist := used[goid]; exist; _, exist = used[goid] {
                                 goid = "_" + goid
                         }
 
                         used[goid] = true
                         ident[cid] = goid
                 }
         }
 
+        bitsRemaining := int64(0)
+
         for _, f := range dt.Field {
+                if bitsRemaining > 0 {

[rsc, 2009/12/16 17:25:21]

I don't think it makes sense to show the first bit field,
since it will be the wrong value anyway. 
It looks like the code already knows to insert padding
when things are missing, so it should suffice to do

if f.BitSize > 0 && f.BitSize != f.ByteSize*8 {
    continue
}

+                        bitsRemaining -= f.BitSize
+                        continue
+                }
                 if f.ByteOffset > off {
                         fld = c.pad(fld, f.ByteOffset-off)
                         off = f.ByteOffset
                 }
                 t := c.Type(f.Type)
                 n := len(fld)
                 fld = fld[0 : n+1]
 
                 fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go}
                 off += t.Size
                 csyntax += t.C + " " + f.Name + "; "
                 if t.Align > align {
                         align = t.Align
                 }
+                // If this is the first member of a bitfield, skip the rest
+                if f.BitSize > 0 {
+                        // 8 bits per byte - number of bits for this field
+                        bitsRemaining = f.ByteSize*8 - f.BitSize
+                }
         }
         if off < dt.ByteSize {
                 fld = c.pad(fld, dt.ByteSize-off)
                 off = dt.ByteSize
         }
         if off != dt.ByteSize {
                 fatal("struct size calculation error")
         }
         csyntax += "}"
         expr = &ast.StructType{Fields: fld}
         return
 }