Source file src/runtime/tagptr_64bit.go
1 // Copyright 2014 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:build amd64 || arm64 || loong64 || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x || wasm 6 7 package runtime 8 9 import ( 10 "internal/goarch" 11 "internal/goos" 12 "unsafe" 13 ) 14 15 const ( 16 // addrBits is the number of bits needed to represent a virtual address. 17 // 18 // See heapAddrBits for a table of address space sizes on 19 // various architectures. 48 bits is enough for all 20 // architectures except s390x. 21 // 22 // On AMD64, virtual addresses are 48-bit (or 57-bit) numbers sign extended to 64. 23 // We shift the address left 16 to eliminate the sign extended part and make 24 // room in the bottom for the count. 25 // 26 // On s390x, virtual addresses are 64-bit. There's not much we 27 // can do about this, so we just hope that the kernel doesn't 28 // get to really high addresses and panic if it does. 29 addrBits = 48 30 31 // In addition to the 16 bits taken from the top, we can take 3 from the 32 // bottom, because node must be pointer-aligned, giving a total of 19 bits 33 // of count. 34 tagBits = 64 - addrBits + 3 35 36 // On AIX, 64-bit addresses are split into 36-bit segment number and 28-bit 37 // offset in segment. Segment numbers in the range 0x0A0000000-0x0AFFFFFFF(LSA) 38 // are available for mmap. 39 // We assume all tagged addresses are from memory allocated with mmap. 40 // We use one bit to distinguish between the two ranges. 41 aixAddrBits = 57 42 aixTagBits = 64 - aixAddrBits + 3 43 44 // riscv64 SV57 mode gives 56 bits of userspace VA. 45 // tagged pointer code supports it, 46 // but broader support for SV57 mode is incomplete, 47 // and there may be other issues (see #54104). 48 riscv64AddrBits = 56 49 riscv64TagBits = 64 - riscv64AddrBits + 3 50 ) 51 52 // The number of bits stored in the numeric tag of a taggedPointer 53 const taggedPointerBits = (goos.IsAix * aixTagBits) + (goarch.IsRiscv64 * riscv64TagBits) + ((1 - goos.IsAix) * (1 - goarch.IsRiscv64) * tagBits) 54 55 // taggedPointerPack created a taggedPointer from a pointer and a tag. 56 // Tag bits that don't fit in the result are discarded. 57 func taggedPointerPack(ptr unsafe.Pointer, tag uintptr) taggedPointer { 58 if GOOS == "aix" { 59 if GOARCH != "ppc64" { 60 throw("check this code for aix on non-ppc64") 61 } 62 return taggedPointer(uint64(uintptr(ptr))<<(64-aixAddrBits) | uint64(tag&(1<<aixTagBits-1))) 63 } 64 if GOARCH == "riscv64" { 65 return taggedPointer(uint64(uintptr(ptr))<<(64-riscv64AddrBits) | uint64(tag&(1<<riscv64TagBits-1))) 66 } 67 return taggedPointer(uint64(uintptr(ptr))<<(64-addrBits) | uint64(tag&(1<<tagBits-1))) 68 } 69 70 // Pointer returns the pointer from a taggedPointer. 71 func (tp taggedPointer) pointer() unsafe.Pointer { 72 if GOARCH == "amd64" { 73 // amd64 systems can place the stack above the VA hole, so we need to sign extend 74 // val before unpacking. 75 return unsafe.Pointer(uintptr(int64(tp) >> tagBits << 3)) 76 } 77 if GOOS == "aix" { 78 return unsafe.Pointer(uintptr((tp >> aixTagBits << 3) | 0xa<<56)) 79 } 80 if GOARCH == "riscv64" { 81 return unsafe.Pointer(uintptr(tp >> riscv64TagBits << 3)) 82 } 83 return unsafe.Pointer(uintptr(tp >> tagBits << 3)) 84 } 85 86 // Tag returns the tag from a taggedPointer. 87 func (tp taggedPointer) tag() uintptr { 88 return uintptr(tp & (1<<taggedPointerBits - 1)) 89 } 90