cybercyst/go
1
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-05-05 15:43:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

runtime: fix tag pointers on aix

Browse Source 
Clean up tagged pointers a bit. I got the shifts wrong
for the weird aix case.

Change-Id: I21449fd5973f4651fd1103d3b8be9c2b9b93a490
Reviewed-on: https://go-review.googlesource.com/c/go/+/667715
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
This commit is contained in:
Keith Randall 2025-04-23 23:23:53 -07:00
parent 8a8f506516
commit 3009566a46
3 changed files with 16 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/runtime/malloc.go
View File

@ -455,8 +455,8 @@ func mallocinit() {
throw("max pointer/scan bitmap size for headerless objects is too large")
}
if minTagBits > taggedPointerBits {
throw("taggedPointerBits too small")
if minTagBits > tagBits {
throw("tagBits too small")
}
// Initialize the heap.

2
src/runtime/netpoll.go
View File

@ -302,7 +302,7 @@ func (c *pollCache) free(pd *pollDesc) {
// Increment the fdseq field, so that any currently
// running netpoll calls will not mark pd as ready.
fdseq := pd.fdseq.Load()
fdseq = (fdseq + 1) & (1<<taggedPointerBits - 1)
fdseq = (fdseq + 1) & (1<<tagBits - 1)
pd.fdseq.Store(fdseq)
pd.publishInfo()

46
src/runtime/tagptr_64bit.go
View File

@ -17,21 +17,15 @@ const (
//
// See heapAddrBits for a table of address space sizes on
// various architectures. 48 bits is enough for all
// architectures except s390x.
// arch/os combos except s390x, aix, and riscv64.
//
// On AMD64, virtual addresses are 48-bit (or 57-bit) numbers sign extended to 64.
// We shift the address left 16 to eliminate the sign extended part and make
// room in the bottom for the count.
// On AMD64, virtual addresses are 48-bit (or 57-bit) sign-extended.
// Other archs are 48-bit zero-extended.
//
// On s390x, virtual addresses are 64-bit. There's not much we
// can do about this, so we just hope that the kernel doesn't
// get to really high addresses and panic if it does.
addrBits = 48
// In addition to the 16 bits taken from the top, we can take 9 from the
// bottom, because we require pointers to be well-aligned (see tagptr.go:tagAlignBits).
// That gives us a total of 25 bits for the tag.
tagBits = 64 - addrBits + tagAlignBits
defaultAddrBits = 48
// On AIX, 64-bit addresses are split into 36-bit segment number and 28-bit
// offset in segment. Segment numbers in the range 0x0A0000000-0x0AFFFFFFF(LSA)
@ -39,33 +33,25 @@ const (
// We assume all tagged addresses are from memory allocated with mmap.
// We use one bit to distinguish between the two ranges.
aixAddrBits = 57
aixTagBits = 64 - aixAddrBits + tagAlignBits
// riscv64 SV57 mode gives 56 bits of userspace VA.
// tagged pointer code supports it,
// but broader support for SV57 mode is incomplete,
// and there may be other issues (see #54104).
riscv64AddrBits = 56
riscv64TagBits = 64 - riscv64AddrBits + tagAlignBits
)
// The number of bits stored in the numeric tag of a taggedPointer
const taggedPointerBits = (goos.IsAix * aixTagBits) + (goarch.IsRiscv64 * riscv64TagBits) + ((1 - goos.IsAix) * (1 - goarch.IsRiscv64) * tagBits)
addrBits = goos.IsAix*aixAddrBits + goarch.IsRiscv64*riscv64AddrBits + (1-goos.IsAix)*(1-goarch.IsRiscv64)*defaultAddrBits
// In addition to the 16 bits (or other, depending on arch/os) taken from the top,
// we can take 9 from the bottom, because we require pointers to be well-aligned
// (see tagptr.go:tagAlignBits). That gives us a total of 25 bits for the tag.
tagBits = 64 - addrBits + tagAlignBits
)
// taggedPointerPack created a taggedPointer from a pointer and a tag.
// Tag bits that don't fit in the result are discarded.
func taggedPointerPack(ptr unsafe.Pointer, tag uintptr) taggedPointer {
var t taggedPointer
if GOOS == "aix" {
if GOARCH != "ppc64" {
throw("check this code for aix on non-ppc64")
}
t = taggedPointer(uint64(uintptr(ptr))<<(64-aixAddrBits) | uint64(tag&(1<<aixTagBits-1)))
} else if GOARCH == "riscv64" {
t = taggedPointer(uint64(uintptr(ptr))<<(64-riscv64AddrBits) | uint64(tag&(1<<riscv64TagBits-1)))
} else {
t = taggedPointer(uint64(uintptr(ptr))<<(64-addrBits) | uint64(tag&(1<<tagBits-1)))
}
t := taggedPointer(uint64(uintptr(ptr))<<(tagBits-tagAlignBits) | uint64(tag&(1<<tagBits-1)))
if t.pointer() != ptr || t.tag() != tag {
print("runtime: taggedPointerPack invalid packing: ptr=", ptr, " tag=", hex(tag), " packed=", hex(t), " -> ptr=", t.pointer(), " tag=", hex(t.tag()), "\n")
throw("taggedPointerPack")
@ -80,16 +66,10 @@ func (tp taggedPointer) pointer() unsafe.Pointer {
// val before unpacking.
return unsafe.Pointer(uintptr(int64(tp) >> tagBits << tagAlignBits))
}
if GOOS == "aix" {
return unsafe.Pointer(uintptr((tp >> aixTagBits << tagAlignBits) | 0xa<<56))
}
if GOARCH == "riscv64" {
return unsafe.Pointer(uintptr(tp >> riscv64TagBits << tagAlignBits))
}
return unsafe.Pointer(uintptr(tp >> tagBits << tagAlignBits))
}
// Tag returns the tag from a taggedPointer.
func (tp taggedPointer) tag() uintptr {
return uintptr(tp & (1<<taggedPointerBits - 1))
return uintptr(tp & (1<<tagBits - 1))
}