diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-16 19:19:13 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-16 19:19:13 +0000 |
commit | ccd992355df7192993c666236047820244914598 (patch) | |
tree | f00fea65147227b7743083c6148396f74cd66935 /src/runtime/tagptr_64bit.go | |
parent | Initial commit. (diff) | |
download | golang-1.21-ccd992355df7192993c666236047820244914598.tar.xz golang-1.21-ccd992355df7192993c666236047820244914598.zip |
Adding upstream version 1.21.8.upstream/1.21.8
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/runtime/tagptr_64bit.go')
-rw-r--r-- | src/runtime/tagptr_64bit.go | 89 |
1 files changed, 89 insertions, 0 deletions
diff --git a/src/runtime/tagptr_64bit.go b/src/runtime/tagptr_64bit.go new file mode 100644 index 0000000..9ff11cc --- /dev/null +++ b/src/runtime/tagptr_64bit.go @@ -0,0 +1,89 @@ +// Copyright 2014 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. + +//go:build amd64 || arm64 || loong64 || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x || wasm + +package runtime + +import ( + "internal/goarch" + "internal/goos" + "unsafe" +) + +const ( + // addrBits is the number of bits needed to represent a virtual address. + // + // See heapAddrBits for a table of address space sizes on + // various architectures. 48 bits is enough for all + // architectures except s390x. + // + // 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 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 3 from the + // bottom, because node must be pointer-aligned, giving a total of 19 bits + // of count. + tagBits = 64 - addrBits + 3 + + // 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) + // are available for mmap. + // 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 + 3 + + // 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 + 3 +) + +// 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) + +// 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 { + if GOOS == "aix" { + if GOARCH != "ppc64" { + throw("check this code for aix on non-ppc64") + } + return taggedPointer(uint64(uintptr(ptr))<<(64-aixAddrBits) | uint64(tag&(1<<aixTagBits-1))) + } + if GOARCH == "riscv64" { + return taggedPointer(uint64(uintptr(ptr))<<(64-riscv64AddrBits) | uint64(tag&(1<<riscv64TagBits-1))) + } + return taggedPointer(uint64(uintptr(ptr))<<(64-addrBits) | uint64(tag&(1<<tagBits-1))) +} + +// Pointer returns the pointer from a taggedPointer. +func (tp taggedPointer) pointer() unsafe.Pointer { + if GOARCH == "amd64" { + // amd64 systems can place the stack above the VA hole, so we need to sign extend + // val before unpacking. + return unsafe.Pointer(uintptr(int64(tp) >> tagBits << 3)) + } + if GOOS == "aix" { + return unsafe.Pointer(uintptr((tp >> aixTagBits << 3) | 0xa<<56)) + } + if GOARCH == "riscv64" { + return unsafe.Pointer(uintptr(tp >> riscv64TagBits << 3)) + } + return unsafe.Pointer(uintptr(tp >> tagBits << 3)) +} + +// Tag returns the tag from a taggedPointer. +func (tp taggedPointer) tag() uintptr { + return uintptr(tp & (1<<taggedPointerBits - 1)) +} |