Your IP : 172.28.240.42
// Copyright 2023 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.
package abi
// These functions are the build-time version of the Go type data structures.
// Their contents must be kept in sync with their definitions.
// Because the host and target type sizes can differ, the compiler and
// linker cannot use the host information that they might get from
// either unsafe.Sizeof and Alignof, nor runtime, reflect, or reflectlite.
// CommonSize returns sizeof(Type) for a compilation target with a given ptrSize
func CommonSize(ptrSize int) int { return 4*ptrSize + 8 + 8 }
// StructFieldSize returns sizeof(StructField) for a compilation target with a given ptrSize
func StructFieldSize(ptrSize int) int { return 3 * ptrSize }
// UncommonSize returns sizeof(UncommonType). This currently does not depend on ptrSize.
// This exported function is in an internal package, so it may change to depend on ptrSize in the future.
func UncommonSize() uint64 { return 4 + 2 + 2 + 4 + 4 }
// IMethodSize returns sizeof(IMethod) for a compilation target with a given ptrSize
func IMethodSize(ptrSize int) int { return 4 + 4 }
// KindOff returns the offset of Type.Kind_ for a compilation target with a given ptrSize
func KindOff(ptrSize int) int { return 2*ptrSize + 7 }
// SizeOff returns the offset of Type.Size_ for a compilation target with a given ptrSize
func SizeOff(ptrSize int) int { return 0 }
// PtrBytes returns the offset of Type.PtrBytes for a compilation target with a given ptrSize
func PtrBytesOff(ptrSize int) int { return ptrSize }
// TFlagOff returns the offset of Type.TFlag for a compilation target with a given ptrSize
func TFlagOff(ptrSize int) int { return 2*ptrSize + 4 }
// Offset is for computing offsets of type data structures at compile/link time;
// the target platform may not be the host platform. Its state includes the
// current offset, necessary alignment for the sequence of types, and the size
// of pointers and alignment of slices, interfaces, and strings (this is for tearing-
// resistant access to these types, if/when that is supported).
type Offset struct {
off uint64 // the current offset
align uint8 // the required alignmentof the container
ptrSize uint8 // the size of a pointer in bytes
sliceAlign uint8 // the alignment of slices (and interfaces and strings)
}
// NewOffset returns a new Offset with offset 0 and alignment 1.
func NewOffset(ptrSize uint8, twoWordAlignSlices bool) Offset {
if twoWordAlignSlices {
return Offset{off: 0, align: 1, ptrSize: ptrSize, sliceAlign: 2 * ptrSize}
}
return Offset{off: 0, align: 1, ptrSize: ptrSize, sliceAlign: ptrSize}
}
func assertIsAPowerOfTwo(x uint8) {
if x == 0 {
panic("Zero is not a power of two")
}
if x&-x == x {
return
}
panic("Not a power of two")
}
// InitializedOffset returns a new Offset with specified offset, alignment, pointer size, and slice alignment.
func InitializedOffset(off int, align uint8, ptrSize uint8, twoWordAlignSlices bool) Offset {
assertIsAPowerOfTwo(align)
o0 := NewOffset(ptrSize, twoWordAlignSlices)
o0.off = uint64(off)
o0.align = align
return o0
}
func (o Offset) align_(a uint8) Offset {
o.off = (o.off + uint64(a) - 1) & ^(uint64(a) - 1)
if o.align < a {
o.align = a
}
return o
}
// Align returns the offset obtained by aligning offset to a multiple of a.
// a must be a power of two.
func (o Offset) Align(a uint8) Offset {
assertIsAPowerOfTwo(a)
return o.align_(a)
}
// plus returns the offset obtained by appending a power-of-2-sized-and-aligned object to o.
func (o Offset) plus(x uint64) Offset {
o = o.align_(uint8(x))
o.off += x
return o
}
// D8 returns the offset obtained by appending an 8-bit field to o.
func (o Offset) D8() Offset {
return o.plus(1)
}
// D16 returns the offset obtained by appending a 16-bit field to o.
func (o Offset) D16() Offset {
return o.plus(2)
}
// D32 returns the offset obtained by appending a 32-bit field to o.
func (o Offset) D32() Offset {
return o.plus(4)
}
// D64 returns the offset obtained by appending a 64-bit field to o.
func (o Offset) D64() Offset {
return o.plus(8)
}
// D64 returns the offset obtained by appending a pointer field to o.
func (o Offset) P() Offset {
if o.ptrSize == 0 {
panic("This offset has no defined pointer size")
}
return o.plus(uint64(o.ptrSize))
}
// Slice returns the offset obtained by appending a slice field to o.
func (o Offset) Slice() Offset {
o = o.align_(o.sliceAlign)
o.off += 3 * uint64(o.ptrSize)
// There's been discussion of whether slices should be 2-word aligned to allow
// use of aligned 2-word load/store to prevent tearing, this is future proofing.
// In general, for purposes of struct layout (and very likely default C layout
// compatibility) the "size" of a Go type is rounded up to its alignment.
return o.Align(o.sliceAlign)
}
// String returns the offset obtained by appending a string field to o.
func (o Offset) String() Offset {
o = o.align_(o.sliceAlign)
o.off += 2 * uint64(o.ptrSize)
return o // We "know" it needs no further alignment
}
// Interface returns the offset obtained by appending an interface field to o.
func (o Offset) Interface() Offset {
o = o.align_(o.sliceAlign)
o.off += 2 * uint64(o.ptrSize)
return o // We "know" it needs no further alignment
}
// Offset returns the struct-aligned offset (size) of o.
// This is at least as large as the current internal offset; it may be larger.
func (o Offset) Offset() uint64 {
return o.Align(o.align).off
}
func (o Offset) PlusUncommon() Offset {
o.off += UncommonSize()
return o
}
// CommonOffset returns the Offset to the data after the common portion of type data structures.
func CommonOffset(ptrSize int, twoWordAlignSlices bool) Offset {
return InitializedOffset(CommonSize(ptrSize), uint8(ptrSize), uint8(ptrSize), twoWordAlignSlices)
}