| 1 |
// Copyright 2013 The Go Authors. All rights reserved. |
| 2 |
// Use of this source code is governed by a BSD-style |
| 3 |
// license that can be found in the LICENSE file. |
| 4 |
|
| 5 |
// Package gcsizes provides a types.Sizes implementation that adheres |
| 6 |
// to the rules used by the gc compiler. |
| 7 |
package gcsizes |
| 8 |
|
| 9 |
import ( |
| 10 |
"go/build" |
| 11 |
"go/types" |
| 12 |
) |
| 13 |
|
| 14 |
type Sizes struct { |
| 15 |
WordSize int64 |
| 16 |
MaxAlign int64 |
| 17 |
} |
| 18 |
|
| 19 |
// ForArch returns a correct Sizes for the given architecture. |
| 20 |
func ForArch(arch string) *Sizes { |
| 21 |
wordSize := int64(8) |
| 22 |
maxAlign := int64(8) |
| 23 |
switch build.Default.GOARCH { |
| 24 |
case "386", "arm": |
| 25 |
wordSize, maxAlign = 4, 4 |
| 26 |
case "amd64p32": |
| 27 |
wordSize = 4 |
| 28 |
} |
| 29 |
return &Sizes{WordSize: wordSize, MaxAlign: maxAlign} |
| 30 |
} |
| 31 |
|
| 32 |
func (s *Sizes) Alignof(T types.Type) int64 { |
| 33 |
switch t := T.Underlying().(type) { |
| 34 |
case *types.Array: |
| 35 |
return s.Alignof(t.Elem()) |
| 36 |
case *types.Struct: |
| 37 |
max := int64(1) |
| 38 |
n := t.NumFields() |
| 39 |
var fields []*types.Var |
| 40 |
for i := range n { |
| 41 |
fields = append(fields, t.Field(i)) |
| 42 |
} |
| 43 |
for _, f := range fields { |
| 44 |
if a := s.Alignof(f.Type()); a > max { |
| 45 |
max = a |
| 46 |
} |
| 47 |
} |
| 48 |
return max |
| 49 |
} |
| 50 |
a := s.Sizeof(T) // may be 0 |
| 51 |
if a < 1 { |
| 52 |
return 1 |
| 53 |
} |
| 54 |
if a > s.MaxAlign { |
| 55 |
return s.MaxAlign |
| 56 |
} |
| 57 |
return a |
| 58 |
} |
| 59 |
|
| 60 |
func (s *Sizes) Offsetsof(fields []*types.Var) []int64 { |
| 61 |
offsets := make([]int64, len(fields)) |
| 62 |
var o int64 |
| 63 |
for i, f := range fields { |
| 64 |
a := s.Alignof(f.Type()) |
| 65 |
o = align(o, a) |
| 66 |
offsets[i] = o |
| 67 |
o += s.Sizeof(f.Type()) |
| 68 |
} |
| 69 |
return offsets |
| 70 |
} |
| 71 |
|
| 72 |
var basicSizes = [...]byte{ |
| 73 |
types.Bool: 1, |
| 74 |
types.Int8: 1, |
| 75 |
types.Int16: 2, |
| 76 |
types.Int32: 4, |
| 77 |
types.Int64: 8, |
| 78 |
types.Uint8: 1, |
| 79 |
types.Uint16: 2, |
| 80 |
types.Uint32: 4, |
| 81 |
types.Uint64: 8, |
| 82 |
types.Float32: 4, |
| 83 |
types.Float64: 8, |
| 84 |
types.Complex64: 8, |
| 85 |
types.Complex128: 16, |
| 86 |
} |
| 87 |
|
| 88 |
func (s *Sizes) Sizeof(T types.Type) int64 { |
| 89 |
switch t := T.Underlying().(type) { |
| 90 |
case *types.Basic: |
| 91 |
k := t.Kind() |
| 92 |
if int(k) < len(basicSizes) { |
| 93 |
if s := basicSizes[k]; s > 0 { |
| 94 |
return int64(s) |
| 95 |
} |
| 96 |
} |
| 97 |
if k == types.String { |
| 98 |
return s.WordSize * 2 |
| 99 |
} |
| 100 |
case *types.Array: |
| 101 |
n := t.Len() |
| 102 |
if n == 0 { |
| 103 |
return 0 |
| 104 |
} |
| 105 |
a := s.Alignof(t.Elem()) |
| 106 |
z := s.Sizeof(t.Elem()) |
| 107 |
return align(z, a)*(n-1) + z |
| 108 |
case *types.Slice: |
| 109 |
return s.WordSize * 3 |
| 110 |
case *types.Struct: |
| 111 |
n := t.NumFields() |
| 112 |
if n == 0 { |
| 113 |
return 0 |
| 114 |
} |
| 115 |
|
| 116 |
var fields []*types.Var |
| 117 |
for i := range n { |
| 118 |
fields = append(fields, t.Field(i)) |
| 119 |
} |
| 120 |
offsets := s.Offsetsof(fields) |
| 121 |
a := s.Alignof(T) |
| 122 |
lsz := s.Sizeof(fields[n-1].Type()) |
| 123 |
if lsz == 0 { |
| 124 |
lsz = 1 |
| 125 |
} |
| 126 |
z := offsets[n-1] + lsz |
| 127 |
return align(z, a) |
| 128 |
case *types.Interface: |
| 129 |
return s.WordSize * 2 |
| 130 |
} |
| 131 |
return s.WordSize // catch-all |
| 132 |
} |
| 133 |
|
| 134 |
// align returns the smallest y >= x such that y % a == 0. |
| 135 |
func align(x, a int64) int64 { |
| 136 |
y := x + a - 1 |
| 137 |
return y - y%a |
| 138 |
} |