+++ /dev/null
-// structlayout-optimize reorders struct fields to minimize the amount
-// of padding.
-package main
-
-import (
- "encoding/json"
- "flag"
- "fmt"
- "log"
- "os"
- "sort"
- "strings"
-
- st "honnef.co/go/tools/structlayout"
- "honnef.co/go/tools/version"
-)
-
-var (
- fJSON bool
- fRecurse bool
- fVersion bool
-)
-
-func init() {
- flag.BoolVar(&fJSON, "json", false, "Format data as JSON")
- flag.BoolVar(&fRecurse, "r", false, "Break up structs and reorder their fields freely")
- flag.BoolVar(&fVersion, "version", false, "Print version and exit")
-}
-
-func main() {
- log.SetFlags(0)
- flag.Parse()
-
- if fVersion {
- version.Print()
- os.Exit(0)
- }
-
- var in []st.Field
- if err := json.NewDecoder(os.Stdin).Decode(&in); err != nil {
- log.Fatal(err)
- }
- if len(in) == 0 {
- return
- }
- if !fRecurse {
- in = combine(in)
- }
- var fields []st.Field
- for _, field := range in {
- if field.IsPadding {
- continue
- }
- fields = append(fields, field)
- }
- optimize(fields)
- fields = pad(fields)
-
- if fJSON {
- json.NewEncoder(os.Stdout).Encode(fields)
- } else {
- for _, field := range fields {
- fmt.Println(field)
- }
- }
-}
-
-func combine(fields []st.Field) []st.Field {
- new := st.Field{}
- cur := ""
- var out []st.Field
- wasPad := true
- for _, field := range fields {
- var prefix string
- if field.IsPadding {
- wasPad = true
- continue
- }
- p := strings.Split(field.Name, ".")
- prefix = strings.Join(p[:2], ".")
- if field.Align > new.Align {
- new.Align = field.Align
- }
- if !wasPad {
- new.End = field.Start
- new.Size = new.End - new.Start
- }
- if prefix != cur {
- if cur != "" {
- out = append(out, new)
- }
- cur = prefix
- new = field
- new.Name = prefix
- } else {
- new.Type = "struct"
- }
- wasPad = false
- }
- new.Size = new.End - new.Start
- out = append(out, new)
- return out
-}
-
-func optimize(fields []st.Field) {
- sort.Sort(&byAlignAndSize{fields})
-}
-
-func pad(fields []st.Field) []st.Field {
- if len(fields) == 0 {
- return nil
- }
- var out []st.Field
- pos := int64(0)
- offsets := offsetsof(fields)
- alignment := int64(1)
- for i, field := range fields {
- if field.Align > alignment {
- alignment = field.Align
- }
- if offsets[i] > pos {
- padding := offsets[i] - pos
- out = append(out, st.Field{
- IsPadding: true,
- Start: pos,
- End: pos + padding,
- Size: padding,
- })
- pos += padding
- }
- field.Start = pos
- field.End = pos + field.Size
- out = append(out, field)
- pos += field.Size
- }
- sz := size(out)
- pad := align(sz, alignment) - sz
- if pad > 0 {
- field := out[len(out)-1]
- out = append(out, st.Field{
- IsPadding: true,
- Start: field.End,
- End: field.End + pad,
- Size: pad,
- })
- }
- return out
-}
-
-func size(fields []st.Field) int64 {
- n := int64(0)
- for _, field := range fields {
- n += field.Size
- }
- return n
-}
-
-type byAlignAndSize struct {
- fields []st.Field
-}
-
-func (s *byAlignAndSize) Len() int { return len(s.fields) }
-func (s *byAlignAndSize) Swap(i, j int) {
- s.fields[i], s.fields[j] = s.fields[j], s.fields[i]
-}
-
-func (s *byAlignAndSize) Less(i, j int) bool {
- // Place zero sized objects before non-zero sized objects.
- if s.fields[i].Size == 0 && s.fields[j].Size != 0 {
- return true
- }
- if s.fields[j].Size == 0 && s.fields[i].Size != 0 {
- return false
- }
-
- // Next, place more tightly aligned objects before less tightly aligned objects.
- if s.fields[i].Align != s.fields[j].Align {
- return s.fields[i].Align > s.fields[j].Align
- }
-
- // Lastly, order by size.
- if s.fields[i].Size != s.fields[j].Size {
- return s.fields[i].Size > s.fields[j].Size
- }
-
- return false
-}
-
-func offsetsof(fields []st.Field) []int64 {
- offsets := make([]int64, len(fields))
- var o int64
- for i, f := range fields {
- a := f.Align
- o = align(o, a)
- offsets[i] = o
- o += f.Size
- }
- return offsets
-}
-
-// align returns the smallest y >= x such that y % a == 0.
-func align(x, a int64) int64 {
- y := x + a - 1
- return y - y%a
-}
projects / dotfiles / .git / blobdiff