libgo/go/go/types/sizes.go

   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 // This file implements Sizes.
   6
   7 package types
   8
   9 // Sizes defines the sizing functions for package unsafe.
  10 type Sizes interface {
  11         // Alignof returns the alignment of a variable of type T.
  12         // Alignof must implement the alignment guarantees required by the spec.
  13         Alignof(T Type) int64
  14
  15         // Offsetsof returns the offsets of the given struct fields, in bytes.
  16         // Offsetsof must implement the offset guarantees required by the spec.
  17         Offsetsof(fields []*Var) []int64
  18
  19         // Sizeof returns the size of a variable of type T.
  20         // Sizeof must implement the size guarantees required by the spec.
  21         Sizeof(T Type) int64
  22 }
  23
  24 // StdSizes is a convenience type for creating commonly used Sizes.
  25 // It makes the following simplifying assumptions:
  26 //
  27 //      - The size of explicitly sized basic types (int16, etc.) is the
  28 //        specified size.
  29 //      - The size of strings and interfaces is 2*WordSize.
  30 //      - The size of slices is 3*WordSize.
  31 //      - The size of an array of n elements corresponds to the size of
  32 //        a struct of n consecutive fields of the array's element type.
  33 //      - The size of a struct is the offset of the last field plus that
  34 //        field's size. As with all element types, if the struct is used
  35 //        in an array its size must first be aligned to a multiple of the
  36 //        struct's alignment.
  37 //      - All other types have size WordSize.
  38 //      - Arrays and structs are aligned per spec definition; all other
  39 //        types are naturally aligned with a maximum alignment MaxAlign.
  40 //
  41 // *StdSizes implements Sizes.
  42 //
  43 type StdSizes struct {
  44         WordSize int64 // word size in bytes - must be >= 4 (32bits)
  45         MaxAlign int64 // maximum alignment in bytes - must be >= 1
  46 }
  47
  48 func (s *StdSizes) Alignof(T Type) int64 {
  49         // For arrays and structs, alignment is defined in terms
  50         // of alignment of the elements and fields, respectively.
  51         switch t := T.Underlying().(type) {
  52         case *Array:
  53                 // spec: "For a variable x of array type: unsafe.Alignof(x)
  54                 // is the same as unsafe.Alignof(x[0]), but at least 1."
  55                 return s.Alignof(t.elem)
  56         case *Struct:
  57                 // spec: "For a variable x of struct type: unsafe.Alignof(x)
  58                 // is the largest of the values unsafe.Alignof(x.f) for each
  59                 // field f of x, but at least 1."
  60                 max := int64(1)
  61                 for _, f := range t.fields {
  62                         if a := s.Alignof(f.typ); a > max {
  63                                 max = a
  64                         }
  65                 }
  66                 return max
  67         case *Slice, *Interface:
  68                 // Multiword data structures are effectively structs
  69                 // in which each element has size WordSize.
  70                 return s.WordSize
  71         case *Basic:
  72                 // Strings are like slices and interfaces.
  73                 if t.Info()&IsString != 0 {
  74                         return s.WordSize
  75                 }
  76         }
  77         a := s.Sizeof(T) // may be 0
  78         // spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
  79         if a < 1 {
  80                 return 1
  81         }
  82         // complex{64,128} are aligned like [2]float{32,64}.
  83         if isComplex(T) {
  84                 a /= 2
  85         }
  86         if a > s.MaxAlign {
  87                 return s.MaxAlign
  88         }
  89         return a
  90 }
  91
  92 func (s *StdSizes) Offsetsof(fields []*Var) []int64 {
  93         offsets := make([]int64, len(fields))
  94         var o int64
  95         for i, f := range fields {
  96                 a := s.Alignof(f.typ)
  97                 o = align(o, a)
  98                 offsets[i] = o
  99                 o += s.Sizeof(f.typ)
 100         }
 101         return offsets
 102 }
 103
 104 var basicSizes = [...]byte{
 105         Bool:       1,
 106         Int8:       1,
 107         Int16:      2,
 108         Int32:      4,
 109         Int64:      8,
 110         Uint8:      1,
 111         Uint16:     2,
 112         Uint32:     4,
 113         Uint64:     8,
 114         Float32:    4,
 115         Float64:    8,
 116         Complex64:  8,
 117         Complex128: 16,
 118 }
 119
 120 func (s *StdSizes) Sizeof(T Type) int64 {
 121         switch t := T.Underlying().(type) {
 122         case *Basic:
 123                 assert(isTyped(T))
 124                 k := t.kind
 125                 if int(k) < len(basicSizes) {
 126                         if s := basicSizes[k]; s > 0 {
 127                                 return int64(s)
 128                         }
 129                 }
 130                 if k == String {
 131                         return s.WordSize * 2
 132                 }
 133         case *Array:
 134                 n := t.len
 135                 if n <= 0 {
 136                         return 0
 137                 }
 138                 // n > 0
 139                 a := s.Alignof(t.elem)
 140                 z := s.Sizeof(t.elem)
 141                 return align(z, a)*(n-1) + z
 142         case *Slice:
 143                 return s.WordSize * 3
 144         case *Struct:
 145                 n := t.NumFields()
 146                 if n == 0 {
 147                         return 0
 148                 }
 149                 offsets := s.Offsetsof(t.fields)
 150                 return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
 151         case *Interface:
 152                 return s.WordSize * 2
 153         }
 154         return s.WordSize // catch-all
 155 }
 156
 157 // common architecture word sizes and alignments
 158 var gcArchSizes = map[string]*StdSizes{
 159         "386":      {4, 4},
 160         "arm":      {4, 4},
 161         "arm64":    {8, 8},
 162         "amd64":    {8, 8},
 163         "amd64p32": {4, 8},
 164         "mips":     {4, 4},
 165         "mipsle":   {4, 4},
 166         "mips64":   {8, 8},
 167         "mips64le": {8, 8},
 168         "ppc64":    {8, 8},
 169         "ppc64le":  {8, 8},
 170         "riscv64":  {8, 8},
 171         "s390x":    {8, 8},
 172         "wasm":     {8, 8},
 173         // When adding more architectures here,
 174         // update the doc string of SizesFor below.
 175 }
 176
 177 // SizesFor returns the Sizes used by a compiler for an architecture.
 178 // The result is nil if a compiler/architecture pair is not known.
 179 //
 180 // Supported architectures for compiler "gc":
 181 // "386", "arm", "arm64", "amd64", "amd64p32", "mips", "mipsle",
 182 // "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "wasm".
 183 func SizesFor(compiler, arch string) Sizes {
 184         var m map[string]*StdSizes
 185         switch compiler {
 186         case "gc":
 187                 m = gcArchSizes
 188         case "gccgo":
 189                 m = gccgoArchSizes
 190         default:
 191                 return nil
 192         }
 193         s, ok := m[arch]
 194         if !ok {
 195                 return nil
 196         }
 197         return s
 198 }
 199
 200 // stdSizes is used if Config.Sizes == nil.
 201 var stdSizes = SizesFor("gc", "amd64")
 202
 203 func (conf *Config) alignof(T Type) int64 {
 204         if s := conf.Sizes; s != nil {
 205                 if a := s.Alignof(T); a >= 1 {
 206                         return a
 207                 }
 208                 panic("Config.Sizes.Alignof returned an alignment < 1")
 209         }
 210         return stdSizes.Alignof(T)
 211 }
 212
 213 func (conf *Config) offsetsof(T *Struct) []int64 {
 214         var offsets []int64
 215         if T.NumFields() > 0 {
 216                 // compute offsets on demand
 217                 if s := conf.Sizes; s != nil {
 218                         offsets = s.Offsetsof(T.fields)
 219                         // sanity checks
 220                         if len(offsets) != T.NumFields() {
 221                                 panic("Config.Sizes.Offsetsof returned the wrong number of offsets")
 222                         }
 223                         for _, o := range offsets {
 224                                 if o < 0 {
 225                                         panic("Config.Sizes.Offsetsof returned an offset < 0")
 226                                 }
 227                         }
 228                 } else {
 229                         offsets = stdSizes.Offsetsof(T.fields)
 230                 }
 231         }
 232         return offsets
 233 }
 234
 235 // offsetof returns the offset of the field specified via
 236 // the index sequence relative to typ. All embedded fields
 237 // must be structs (rather than pointer to structs).
 238 func (conf *Config) offsetof(typ Type, index []int) int64 {
 239         var o int64
 240         for _, i := range index {
 241                 s := typ.Underlying().(*Struct)
 242                 o += conf.offsetsof(s)[i]
 243                 typ = s.fields[i].typ
 244         }
 245         return o
 246 }
 247
 248 func (conf *Config) sizeof(T Type) int64 {
 249         if s := conf.Sizes; s != nil {
 250                 if z := s.Sizeof(T); z >= 0 {
 251                         return z
 252                 }
 253                 panic("Config.Sizes.Sizeof returned a size < 0")
 254         }
 255         return stdSizes.Sizeof(T)
 256 }
 257
 258 // align returns the smallest y >= x such that y % a == 0.
 259 func align(x, a int64) int64 {
 260         y := x + a - 1
 261         return y - y%a
 262 }