548 lines
15 KiB
Go
548 lines
15 KiB
Go
package abi
|
|
|
|
import (
|
|
"go/token"
|
|
"go/types"
|
|
"log"
|
|
|
|
"github.com/goplus/llgo/runtime/abi"
|
|
)
|
|
|
|
// Builds a type representing a Bucket structure for
|
|
// the given map type. This type is not visible to users -
|
|
// we include only enough information to generate a correct GC
|
|
// program for it.
|
|
// Make sure this stays in sync with runtime/map.go.
|
|
//
|
|
// A "bucket" is a "struct" {
|
|
// tophash [BUCKETSIZE]uint8
|
|
// keys [BUCKETSIZE]keyType
|
|
// elems [BUCKETSIZE]elemType
|
|
// overflow *bucket
|
|
// }
|
|
const (
|
|
BUCKETSIZE = abi.MapBucketCount
|
|
MAXKEYSIZE = abi.MapMaxKeyBytes
|
|
MAXELEMSIZE = abi.MapMaxElemBytes
|
|
)
|
|
|
|
func makefield(name string, t types.Type) *types.Var {
|
|
return types.NewField(token.NoPos, nil, name, t, false)
|
|
}
|
|
|
|
// MapBucketType makes the map bucket type given the type of the map.
|
|
func MapBucketType(t *types.Map, sizes types.Sizes) types.Type {
|
|
keytype := t.Key()
|
|
elemtype := t.Elem()
|
|
if sizes.Sizeof(keytype) > MAXKEYSIZE {
|
|
keytype = types.NewPointer(keytype)
|
|
}
|
|
if sizes.Sizeof(elemtype) > MAXELEMSIZE {
|
|
elemtype = types.NewPointer(elemtype)
|
|
}
|
|
|
|
field := make([]*types.Var, 0, 5)
|
|
|
|
// The first field is: uint8 topbits[BUCKETSIZE].
|
|
arr := types.NewArray(types.Typ[types.Uint8], BUCKETSIZE)
|
|
field = append(field, makefield("topbits", arr))
|
|
|
|
arr = types.NewArray(keytype, BUCKETSIZE)
|
|
//arr.SetNoalg(true)
|
|
keys := makefield("keys", arr)
|
|
field = append(field, keys)
|
|
|
|
arr = types.NewArray(elemtype, BUCKETSIZE)
|
|
//arr.SetNoalg(true)
|
|
elems := makefield("elems", arr)
|
|
field = append(field, elems)
|
|
|
|
// If keys and elems have no pointers, the map implementation
|
|
// can keep a list of overflow pointers on the side so that
|
|
// buckets can be marked as having no pointers.
|
|
// Arrange for the bucket to have no pointers by changing
|
|
// the type of the overflow field to uintptr in this case.
|
|
// See comment on hmap.overflow in runtime/map.go.
|
|
otyp := types.Typ[types.UnsafePointer]
|
|
if !HasPtrData(elemtype) && !HasPtrData(keytype) {
|
|
otyp = types.Typ[types.Uintptr]
|
|
}
|
|
overflow := makefield("overflow", otyp)
|
|
field = append(field, overflow)
|
|
|
|
// link up fields
|
|
bucket := types.NewStruct(field[:], nil)
|
|
|
|
// Check invariants that map code depends on.
|
|
if !types.Comparable(t.Key()) {
|
|
log.Fatalf("unsupported map key type for %v", t)
|
|
}
|
|
if BUCKETSIZE < 8 {
|
|
log.Fatalf("bucket size %d too small for proper alignment %d", BUCKETSIZE, 8)
|
|
}
|
|
if uint8(sizes.Alignof(keytype)) > BUCKETSIZE {
|
|
log.Fatalf("key align too big for %v", t)
|
|
}
|
|
if uint8(sizes.Alignof(elemtype)) > BUCKETSIZE {
|
|
log.Fatalf("elem align %d too big for %v, BUCKETSIZE=%d", sizes.Alignof(elemtype), t, BUCKETSIZE)
|
|
}
|
|
if sizes.Alignof(keytype) > MAXKEYSIZE {
|
|
log.Fatalf("key size too large for %v", t)
|
|
}
|
|
if sizes.Alignof(elemtype) > MAXELEMSIZE {
|
|
log.Fatalf("elem size too large for %v", t)
|
|
}
|
|
if sizes.Alignof(t.Key()) > MAXKEYSIZE && !isPointer(keytype) {
|
|
log.Fatalf("key indirect incorrect for %v", t)
|
|
}
|
|
if sizes.Alignof(t.Elem()) > MAXELEMSIZE && !isPointer(elemtype) {
|
|
log.Fatalf("elem indirect incorrect for %v", t)
|
|
}
|
|
if sizes.Sizeof(keytype)%sizes.Alignof(keytype) != 0 {
|
|
log.Fatalf("key size not a multiple of key align for %v", t)
|
|
}
|
|
if sizes.Sizeof(elemtype)%sizes.Alignof(elemtype) != 0 {
|
|
log.Fatalf("elem size not a multiple of elem align for %v", t)
|
|
}
|
|
if uint8(sizes.Alignof(bucket))%uint8(sizes.Alignof(keytype)) != 0 {
|
|
log.Fatalf("bucket align not multiple of key align %v", t)
|
|
}
|
|
if uint8(sizes.Alignof(bucket))%uint8(sizes.Alignof(elemtype)) != 0 {
|
|
log.Fatalf("bucket align not multiple of elem align %v", t)
|
|
}
|
|
offs := sizes.Offsetsof(field)
|
|
if offs[1]%sizes.Alignof(keytype) != 0 {
|
|
log.Fatalf("bad alignment of keys in bmap for %v", t)
|
|
}
|
|
if offs[2]%sizes.Alignof(elemtype) != 0 {
|
|
log.Fatalf("bad alignment of elems in bmap for %v", t)
|
|
}
|
|
|
|
// // Double-check that overflow field is final memory in struct,
|
|
// // with no padding at end.
|
|
// if overflow.Offset != bucket.Size()-int64(types.PtrSize) {
|
|
// log.Fatalf("bad offset of overflow in bmap for %v, overflow.Offset=%d, bucket.Size()-int64(types.PtrSize)=%d",
|
|
// t, overflow.Offset, bucket.Size()-int64(types.PtrSize))
|
|
// }
|
|
return bucket
|
|
}
|
|
|
|
func isPointer(t types.Type) (ok bool) {
|
|
_, ok = t.Underlying().(*types.Pointer)
|
|
return
|
|
}
|
|
|
|
func MapTypeFlags(t *types.Map, sizes types.Sizes) (flags int) {
|
|
if sizes.Sizeof(t.Key()) > MAXKEYSIZE {
|
|
flags |= 1 // indirect key
|
|
}
|
|
if sizes.Sizeof(t.Elem()) > MAXELEMSIZE {
|
|
flags |= 2 // indirect value
|
|
}
|
|
if IsReflexive(t.Key()) {
|
|
flags |= 4 // reflexive key
|
|
}
|
|
if needkeyupdate(t.Key()) {
|
|
flags |= 8 // need key update
|
|
}
|
|
if hashMightPanic(t.Key()) {
|
|
flags |= 16 // hash might panic
|
|
}
|
|
return
|
|
}
|
|
|
|
// $GOROOT/src/cmd/compile/internal/reflectdata/reflect.go
|
|
// func MapBucketType(t *types.Type) *types.Type {
|
|
// if t.MapType().Bucket != nil {
|
|
// return t.MapType().Bucket
|
|
// }
|
|
|
|
// keytype := t.Key()
|
|
// elemtype := t.Elem()
|
|
// types.CalcSize(keytype)
|
|
// types.CalcSize(elemtype)
|
|
// if keytype.Size() > MAXKEYSIZE {
|
|
// keytype = types.NewPtr(keytype)
|
|
// }
|
|
// if elemtype.Size() > MAXELEMSIZE {
|
|
// elemtype = types.NewPtr(elemtype)
|
|
// }
|
|
|
|
// field := make([]*types.Field, 0, 5)
|
|
|
|
// // The first field is: uint8 topbits[BUCKETSIZE].
|
|
// arr := types.NewArray(types.Types[types.TUINT8], BUCKETSIZE)
|
|
// field = append(field, makefield("topbits", arr))
|
|
|
|
// arr = types.NewArray(keytype, BUCKETSIZE)
|
|
// arr.SetNoalg(true)
|
|
// keys := makefield("keys", arr)
|
|
// field = append(field, keys)
|
|
|
|
// arr = types.NewArray(elemtype, BUCKETSIZE)
|
|
// arr.SetNoalg(true)
|
|
// elems := makefield("elems", arr)
|
|
// field = append(field, elems)
|
|
|
|
// // If keys and elems have no pointers, the map implementation
|
|
// // can keep a list of overflow pointers on the side so that
|
|
// // buckets can be marked as having no pointers.
|
|
// // Arrange for the bucket to have no pointers by changing
|
|
// // the type of the overflow field to uintptr in this case.
|
|
// // See comment on hmap.overflow in runtime/map.go.
|
|
// otyp := types.Types[types.TUNSAFEPTR]
|
|
// if !elemtype.HasPointers() && !keytype.HasPointers() {
|
|
// otyp = types.Types[types.TUINTPTR]
|
|
// }
|
|
// overflow := makefield("overflow", otyp)
|
|
// field = append(field, overflow)
|
|
|
|
// // link up fields
|
|
// bucket := types.NewStruct(field[:])
|
|
// bucket.SetNoalg(true)
|
|
// types.CalcSize(bucket)
|
|
|
|
// // Check invariants that map code depends on.
|
|
// if !types.IsComparable(t.Key()) {
|
|
// base.Fatalf("unsupported map key type for %v", t)
|
|
// }
|
|
// if BUCKETSIZE < 8 {
|
|
// base.Fatalf("bucket size %d too small for proper alignment %d", BUCKETSIZE, 8)
|
|
// }
|
|
// if uint8(keytype.Alignment()) > BUCKETSIZE {
|
|
// base.Fatalf("key align too big for %v", t)
|
|
// }
|
|
// if uint8(elemtype.Alignment()) > BUCKETSIZE {
|
|
// base.Fatalf("elem align %d too big for %v, BUCKETSIZE=%d", elemtype.Alignment(), t, BUCKETSIZE)
|
|
// }
|
|
// if keytype.Size() > MAXKEYSIZE {
|
|
// base.Fatalf("key size too large for %v", t)
|
|
// }
|
|
// if elemtype.Size() > MAXELEMSIZE {
|
|
// base.Fatalf("elem size too large for %v", t)
|
|
// }
|
|
// if t.Key().Size() > MAXKEYSIZE && !keytype.IsPtr() {
|
|
// base.Fatalf("key indirect incorrect for %v", t)
|
|
// }
|
|
// if t.Elem().Size() > MAXELEMSIZE && !elemtype.IsPtr() {
|
|
// base.Fatalf("elem indirect incorrect for %v", t)
|
|
// }
|
|
// if keytype.Size()%keytype.Alignment() != 0 {
|
|
// base.Fatalf("key size not a multiple of key align for %v", t)
|
|
// }
|
|
// if elemtype.Size()%elemtype.Alignment() != 0 {
|
|
// base.Fatalf("elem size not a multiple of elem align for %v", t)
|
|
// }
|
|
// if uint8(bucket.Alignment())%uint8(keytype.Alignment()) != 0 {
|
|
// base.Fatalf("bucket align not multiple of key align %v", t)
|
|
// }
|
|
// if uint8(bucket.Alignment())%uint8(elemtype.Alignment()) != 0 {
|
|
// base.Fatalf("bucket align not multiple of elem align %v", t)
|
|
// }
|
|
// if keys.Offset%keytype.Alignment() != 0 {
|
|
// base.Fatalf("bad alignment of keys in bmap for %v", t)
|
|
// }
|
|
// if elems.Offset%elemtype.Alignment() != 0 {
|
|
// base.Fatalf("bad alignment of elems in bmap for %v", t)
|
|
// }
|
|
|
|
// // Double-check that overflow field is final memory in struct,
|
|
// // with no padding at end.
|
|
// if overflow.Offset != bucket.Size()-int64(types.PtrSize) {
|
|
// base.Fatalf("bad offset of overflow in bmap for %v, overflow.Offset=%d, bucket.Size()-int64(types.PtrSize)=%d",
|
|
// t, overflow.Offset, bucket.Size()-int64(types.PtrSize))
|
|
// }
|
|
|
|
// t.MapType().Bucket = bucket
|
|
|
|
// bucket.StructType().Map = t
|
|
// return bucket
|
|
// }
|
|
|
|
// PtrDataSize returns the length in bytes of the prefix of t
|
|
// containing pointer data. Anything after this offset is scalar data.
|
|
//
|
|
// PtrDataSize is only defined for actual Go types. It's an error to
|
|
// use it on compiler-internal types (e.g., TSSA, TRESULTS).
|
|
func HasPtrData(t types.Type) bool {
|
|
switch t := t.Underlying().(type) {
|
|
case *types.Basic:
|
|
switch t.Kind() {
|
|
case types.String:
|
|
return true
|
|
case types.UnsafePointer:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
case *types.Pointer:
|
|
return true
|
|
case *types.Signature, *types.Chan, *types.Map:
|
|
return true
|
|
case *types.Interface:
|
|
return true
|
|
case *types.Slice:
|
|
return true
|
|
case *types.Array:
|
|
if t.Len() == 0 {
|
|
return false
|
|
}
|
|
return HasPtrData(t.Elem())
|
|
case *types.Struct:
|
|
for i := 0; i < t.NumFields(); i++ {
|
|
if HasPtrData(t.Field(i).Type()) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
default:
|
|
log.Fatalf("PtrDataSize: unexpected type, %v", t)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// $GOROOT/src/cmd/compile/internal/types/type.go
|
|
// func PtrDataSize(t *Type) int64 {
|
|
// switch t.Kind() {
|
|
// case TBOOL, TINT8, TUINT8, TINT16, TUINT16, TINT32,
|
|
// TUINT32, TINT64, TUINT64, TINT, TUINT,
|
|
// TUINTPTR, TCOMPLEX64, TCOMPLEX128, TFLOAT32, TFLOAT64:
|
|
// return 0
|
|
|
|
// case TPTR:
|
|
// if t.Elem().NotInHeap() {
|
|
// return 0
|
|
// }
|
|
// return int64(PtrSize)
|
|
|
|
// case TUNSAFEPTR, TFUNC, TCHAN, TMAP:
|
|
// return int64(PtrSize)
|
|
|
|
// case TSTRING:
|
|
// // struct { byte *str; intgo len; }
|
|
// return int64(PtrSize)
|
|
|
|
// case TINTER:
|
|
// // struct { Itab *tab; void *data; } or
|
|
// // struct { Type *type; void *data; }
|
|
// // Note: see comment in typebits.Set
|
|
// return 2 * int64(PtrSize)
|
|
|
|
// case TSLICE:
|
|
// if t.Elem().NotInHeap() {
|
|
// return 0
|
|
// }
|
|
// // struct { byte *array; uintgo len; uintgo cap; }
|
|
// return int64(PtrSize)
|
|
|
|
// case TARRAY:
|
|
// if t.NumElem() == 0 {
|
|
// return 0
|
|
// }
|
|
// // t.NumElem() > 0
|
|
// size := PtrDataSize(t.Elem())
|
|
// if size == 0 {
|
|
// return 0
|
|
// }
|
|
// return (t.NumElem()-1)*t.Elem().Size() + size
|
|
|
|
// case TSTRUCT:
|
|
// // Find the last field that has pointers, if any.
|
|
// fs := t.Fields().Slice()
|
|
// for i := len(fs) - 1; i >= 0; i-- {
|
|
// if size := PtrDataSize(fs[i].Type); size > 0 {
|
|
// return fs[i].Offset + size
|
|
// }
|
|
// }
|
|
// return 0
|
|
|
|
// case TSSA:
|
|
// if t != TypeInt128 {
|
|
// base.Fatalf("PtrDataSize: unexpected ssa type %v", t)
|
|
// }
|
|
// return 0
|
|
|
|
// default:
|
|
// base.Fatalf("PtrDataSize: unexpected type, %v", t)
|
|
// return 0
|
|
// }
|
|
// }
|
|
|
|
// IsReflexive reports whether t has a reflexive equality operator.
|
|
// That is, if x==x for all x of type t.
|
|
func IsReflexive(t types.Type) bool {
|
|
switch t := t.Underlying().(type) {
|
|
case *types.Basic:
|
|
switch t.Kind() {
|
|
case types.Float32, types.Float64, types.Complex64, types.Complex128:
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
case *types.Pointer, *types.Chan:
|
|
return true
|
|
case *types.Interface:
|
|
return false
|
|
case *types.Array:
|
|
return IsReflexive(t.Elem())
|
|
case *types.Struct:
|
|
for i, n := 0, t.NumFields(); i < n; i++ {
|
|
if !IsReflexive(t.Field(i).Type()) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
default:
|
|
log.Fatalf("bad type for map key: %v", t)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// $GOROOT/src/cmd/compile/internal/types/type.go
|
|
// func IsReflexive(t *Type) bool {
|
|
// switch t.Kind() {
|
|
// case TBOOL,
|
|
// TINT,
|
|
// TUINT,
|
|
// TINT8,
|
|
// TUINT8,
|
|
// TINT16,
|
|
// TUINT16,
|
|
// TINT32,
|
|
// TUINT32,
|
|
// TINT64,
|
|
// TUINT64,
|
|
// TUINTPTR,
|
|
// TPTR,
|
|
// TUNSAFEPTR,
|
|
// TSTRING,
|
|
// TCHAN:
|
|
// return true
|
|
|
|
// case TFLOAT32,
|
|
// TFLOAT64,
|
|
// TCOMPLEX64,
|
|
// TCOMPLEX128,
|
|
// TINTER:
|
|
// return false
|
|
|
|
// case TARRAY:
|
|
// return IsReflexive(t.Elem())
|
|
|
|
// case TSTRUCT:
|
|
// for _, t1 := range t.Fields().Slice() {
|
|
// if !IsReflexive(t1.Type) {
|
|
// return false
|
|
// }
|
|
// }
|
|
// return true
|
|
|
|
// default:
|
|
// base.Fatalf("bad type for map key: %v", t)
|
|
// return false
|
|
// }
|
|
// }
|
|
|
|
// $GOROOT/src/cmd/compile/internal/types/type.go
|
|
// needkeyupdate reports whether map updates with t as a key
|
|
// need the key to be updated.
|
|
func needkeyupdate(t types.Type) bool {
|
|
switch t := t.Underlying().(type) {
|
|
case *types.Basic:
|
|
switch t.Kind() {
|
|
case types.Float32, types.Float64, types.Complex64, types.Complex128:
|
|
return true // floats and complex can be +0/-0
|
|
case types.String:
|
|
return true // strings might have smaller backing stores
|
|
default:
|
|
return false
|
|
}
|
|
case *types.Interface:
|
|
return true
|
|
case *types.Pointer, *types.Chan:
|
|
return false
|
|
case *types.Array:
|
|
return needkeyupdate(t.Elem())
|
|
case *types.Struct:
|
|
for i, n := 0, t.NumFields(); i < n; i++ {
|
|
if needkeyupdate(t.Field(i).Type()) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
default:
|
|
log.Fatalf("bad type for map key: %v", t)
|
|
return true
|
|
}
|
|
}
|
|
|
|
// $GOROOT/src/cmd/compile/internal/reflectdata/reflect.go
|
|
// func needkeyupdate(t *types.Type) bool {
|
|
// switch t.Kind() {
|
|
// case types.TBOOL, types.TINT, types.TUINT, types.TINT8, types.TUINT8, types.TINT16, types.TUINT16, types.TINT32, types.TUINT32,
|
|
// types.TINT64, types.TUINT64, types.TUINTPTR, types.TPTR, types.TUNSAFEPTR, types.TCHAN:
|
|
// return false
|
|
|
|
// case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128, // floats and complex can be +0/-0
|
|
// types.TINTER,
|
|
// types.TSTRING: // strings might have smaller backing stores
|
|
// return true
|
|
|
|
// case types.TARRAY:
|
|
// return needkeyupdate(t.Elem())
|
|
|
|
// case types.TSTRUCT:
|
|
// for _, t1 := range t.Fields().Slice() {
|
|
// if needkeyupdate(t1.Type) {
|
|
// return true
|
|
// }
|
|
// }
|
|
// return false
|
|
|
|
// default:
|
|
// base.Fatalf("bad type for map key: %v", t)
|
|
// return true
|
|
// }
|
|
// }
|
|
|
|
// hashMightPanic reports whether the hash of a map key of type t might panic.
|
|
func hashMightPanic(t types.Type) bool {
|
|
switch t := t.Underlying().(type) {
|
|
case *types.Interface:
|
|
return true
|
|
case *types.Array:
|
|
return hashMightPanic(t.Elem())
|
|
case *types.Struct:
|
|
for i, n := 0, t.NumFields(); i < n; i++ {
|
|
if hashMightPanic(t.Field(i).Type()) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// $GOROOT/src/cmd/compile/internal/reflectdata/reflect.go
|
|
// func hashMightPanic(t *types.Type) bool {
|
|
// switch t.Kind() {
|
|
// case types.TINTER:
|
|
// return true
|
|
|
|
// case types.TARRAY:
|
|
// return hashMightPanic(t.Elem())
|
|
|
|
// case types.TSTRUCT:
|
|
// for _, t1 := range t.Fields().Slice() {
|
|
// if hashMightPanic(t1.Type) {
|
|
// return true
|
|
// }
|
|
// }
|
|
// return false
|
|
|
|
// default:
|
|
// return false
|
|
// }
|
|
// }
|