mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
all: refer to map elements as elements instead of values
The spec carefully and consistently uses "key" and "element" as map terminology. The implementation, not so much. This change attempts to make the implementation consistently hew to the spec's terminology. Beyond consistency, this has the advantage of avoid some confusion and naming collisions, since v and value are very generic and commonly used terms. I believe that I found all everything, but there are a lot of non-obvious places for these to hide, and grepping for them is hard. Hopefully this change changes enough of them that we will start using elem going forward. Any remaining hidden cases can be removed ad hoc as they are discovered. The only externally-facing part of this change is in package reflect, where there is a minor doc change and a function parameter name change. Updates #27167 Change-Id: I2f2d78f16c360dc39007b9966d5c2046a29d3701 Reviewed-on: https://go-review.googlesource.com/c/go/+/174523 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
This commit is contained in:
Josh Bleecher Snyder
parent
a8d0047e47
commit
73cb9a1cb3
10 changed files with 222 additions and 223 deletions
|
|
@ -56,9 +56,9 @@ type Sig struct {
|
|||
// program for it.
|
||||
// Make sure this stays in sync with runtime/map.go.
|
||||
const (
|
||||
BUCKETSIZE = 8
|
||||
MAXKEYSIZE = 128
|
||||
MAXVALSIZE = 128
|
||||
BUCKETSIZE = 8
|
||||
MAXKEYSIZE = 128
|
||||
MAXELEMSIZE = 128
|
||||
)
|
||||
|
||||
func structfieldSize() int { return 3 * Widthptr } // Sizeof(runtime.structfield{})
|
||||
|
|
@ -86,14 +86,14 @@ func bmap(t *types.Type) *types.Type {
|
|||
|
||||
bucket := types.New(TSTRUCT)
|
||||
keytype := t.Key()
|
||||
valtype := t.Elem()
|
||||
elemtype := t.Elem()
|
||||
dowidth(keytype)
|
||||
dowidth(valtype)
|
||||
dowidth(elemtype)
|
||||
if keytype.Width > MAXKEYSIZE {
|
||||
keytype = types.NewPtr(keytype)
|
||||
}
|
||||
if valtype.Width > MAXVALSIZE {
|
||||
valtype = types.NewPtr(valtype)
|
||||
if elemtype.Width > MAXELEMSIZE {
|
||||
elemtype = types.NewPtr(elemtype)
|
||||
}
|
||||
|
||||
field := make([]*types.Field, 0, 5)
|
||||
|
|
@ -107,10 +107,10 @@ func bmap(t *types.Type) *types.Type {
|
|||
keys := makefield("keys", arr)
|
||||
field = append(field, keys)
|
||||
|
||||
arr = types.NewArray(valtype, BUCKETSIZE)
|
||||
arr = types.NewArray(elemtype, BUCKETSIZE)
|
||||
arr.SetNoalg(true)
|
||||
values := makefield("values", arr)
|
||||
field = append(field, values)
|
||||
elems := makefield("elems", arr)
|
||||
field = append(field, elems)
|
||||
|
||||
// Make sure the overflow pointer is the last memory in the struct,
|
||||
// because the runtime assumes it can use size-ptrSize as the
|
||||
|
|
@ -126,21 +126,21 @@ func bmap(t *types.Type) *types.Type {
|
|||
// will end with no padding.
|
||||
// On nacl/amd64p32, however, the max alignment is 64-bit,
|
||||
// but the overflow pointer will add only a 32-bit field,
|
||||
// so if the struct needs 64-bit padding (because a key or value does)
|
||||
// so if the struct needs 64-bit padding (because a key or elem does)
|
||||
// then it would end with an extra 32-bit padding field.
|
||||
// Preempt that by emitting the padding here.
|
||||
if int(valtype.Align) > Widthptr || int(keytype.Align) > Widthptr {
|
||||
if int(elemtype.Align) > Widthptr || int(keytype.Align) > Widthptr {
|
||||
field = append(field, makefield("pad", types.Types[TUINTPTR]))
|
||||
}
|
||||
|
||||
// If keys and values have no pointers, the map implementation
|
||||
// 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.NewPtr(bucket)
|
||||
if !types.Haspointers(valtype) && !types.Haspointers(keytype) {
|
||||
if !types.Haspointers(elemtype) && !types.Haspointers(keytype) {
|
||||
otyp = types.Types[TUINTPTR]
|
||||
}
|
||||
overflow := makefield("overflow", otyp)
|
||||
|
|
@ -161,38 +161,38 @@ func bmap(t *types.Type) *types.Type {
|
|||
if keytype.Align > BUCKETSIZE {
|
||||
Fatalf("key align too big for %v", t)
|
||||
}
|
||||
if valtype.Align > BUCKETSIZE {
|
||||
Fatalf("value align too big for %v", t)
|
||||
if elemtype.Align > BUCKETSIZE {
|
||||
Fatalf("elem align too big for %v", t)
|
||||
}
|
||||
if keytype.Width > MAXKEYSIZE {
|
||||
Fatalf("key size to large for %v", t)
|
||||
}
|
||||
if valtype.Width > MAXVALSIZE {
|
||||
Fatalf("value size to large for %v", t)
|
||||
if elemtype.Width > MAXELEMSIZE {
|
||||
Fatalf("elem size to large for %v", t)
|
||||
}
|
||||
if t.Key().Width > MAXKEYSIZE && !keytype.IsPtr() {
|
||||
Fatalf("key indirect incorrect for %v", t)
|
||||
}
|
||||
if t.Elem().Width > MAXVALSIZE && !valtype.IsPtr() {
|
||||
Fatalf("value indirect incorrect for %v", t)
|
||||
if t.Elem().Width > MAXELEMSIZE && !elemtype.IsPtr() {
|
||||
Fatalf("elem indirect incorrect for %v", t)
|
||||
}
|
||||
if keytype.Width%int64(keytype.Align) != 0 {
|
||||
Fatalf("key size not a multiple of key align for %v", t)
|
||||
}
|
||||
if valtype.Width%int64(valtype.Align) != 0 {
|
||||
Fatalf("value size not a multiple of value align for %v", t)
|
||||
if elemtype.Width%int64(elemtype.Align) != 0 {
|
||||
Fatalf("elem size not a multiple of elem align for %v", t)
|
||||
}
|
||||
if bucket.Align%keytype.Align != 0 {
|
||||
Fatalf("bucket align not multiple of key align %v", t)
|
||||
}
|
||||
if bucket.Align%valtype.Align != 0 {
|
||||
Fatalf("bucket align not multiple of value align %v", t)
|
||||
if bucket.Align%elemtype.Align != 0 {
|
||||
Fatalf("bucket align not multiple of elem align %v", t)
|
||||
}
|
||||
if keys.Offset%int64(keytype.Align) != 0 {
|
||||
Fatalf("bad alignment of keys in bmap for %v", t)
|
||||
}
|
||||
if values.Offset%int64(valtype.Align) != 0 {
|
||||
Fatalf("bad alignment of values in bmap for %v", t)
|
||||
if elems.Offset%int64(elemtype.Align) != 0 {
|
||||
Fatalf("bad alignment of elems in bmap for %v", t)
|
||||
}
|
||||
|
||||
// Double-check that overflow field is final memory in struct,
|
||||
|
|
@ -270,7 +270,7 @@ func hiter(t *types.Type) *types.Type {
|
|||
// build a struct:
|
||||
// type hiter struct {
|
||||
// key *Key
|
||||
// val *Value
|
||||
// elem *Elem
|
||||
// t unsafe.Pointer // *MapType
|
||||
// h *hmap
|
||||
// buckets *bmap
|
||||
|
|
@ -287,8 +287,8 @@ func hiter(t *types.Type) *types.Type {
|
|||
// }
|
||||
// must match runtime/map.go:hiter.
|
||||
fields := []*types.Field{
|
||||
makefield("key", types.NewPtr(t.Key())), // Used in range.go for TMAP.
|
||||
makefield("val", types.NewPtr(t.Elem())), // Used in range.go for TMAP.
|
||||
makefield("key", types.NewPtr(t.Key())), // Used in range.go for TMAP.
|
||||
makefield("elem", types.NewPtr(t.Elem())), // Used in range.go for TMAP.
|
||||
makefield("t", types.Types[TUNSAFEPTR]),
|
||||
makefield("h", types.NewPtr(hmap)),
|
||||
makefield("buckets", types.NewPtr(bmap)),
|
||||
|
|
@ -1284,7 +1284,7 @@ func dtypesym(t *types.Type) *obj.LSym {
|
|||
ot = duint8(lsym, ot, uint8(t.Key().Width))
|
||||
}
|
||||
|
||||
if t.Elem().Width > MAXVALSIZE {
|
||||
if t.Elem().Width > MAXELEMSIZE {
|
||||
ot = duint8(lsym, ot, uint8(Widthptr))
|
||||
flags |= 2 // indirect value
|
||||
} else {
|
||||
|
|
@ -1894,7 +1894,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
|
|||
// size bytes of zeros.
|
||||
func zeroaddr(size int64) *Node {
|
||||
if size >= 1<<31 {
|
||||
Fatalf("map value too big %d", size)
|
||||
Fatalf("map elem too big %d", size)
|
||||
}
|
||||
if zerosize < size {
|
||||
zerosize = size
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue