runtime: move comment about address space sizes to malloc.go

Currently there's a detailed comment in lfstack_64bit.go about address
space limitations on various architectures. Since that's now relevant
to malloc, move it to a more prominent place in the documentation for
memLimitBits.

Updates #10460.

Change-Id: If9708291cf3a288057b8b3ba0ba6a59e3602bbd6
Reviewed-on: https://go-review.googlesource.com/85889
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Rick Hudson <rlh@golang.org>

2 files changed, 24 insertions, 20 deletions

diff --git a/src/runtime/lfstack_64bit.go b/src/runtime/lfstack_64bit.go
index cf6c02895f..19d8045203 100644
--- a/src/runtime/lfstack_64bit.go
+++ b/src/runtime/lfstack_64bit.go
@@ -11,30 +11,17 @@ import "unsafe"
 const (
 	// addrBits is the number of bits needed to represent a virtual address.
 	//
-	// In Linux the user address space for each architecture is limited as
-	// follows (taken from the processor.h file for the architecture):
-	//
-	// Architecture  Name              Maximum Value (exclusive)
-	// ---------------------------------------------------------------------
-	// amd64         TASK_SIZE_MAX     0x007ffffffff000 (47 bit addresses)
-	// arm64         TASK_SIZE_64      0x01000000000000 (48 bit addresses)
-	// ppc64{,le}    TASK_SIZE_USER64  0x00400000000000 (46 bit addresses)
-	// mips64{,le}   TASK_SIZE64       0x00010000000000 (40 bit addresses)
-	// s390x         TASK_SIZE         1<<64 (64 bit addresses)
-	//
-	// These values may increase over time. In particular, ppc64
-	// and mips64 support arbitrary 64-bit addresses in hardware,
-	// but Linux imposes the above limits. amd64 has hardware
-	// support for 57 bit addresses as of 2017 (56 bits for user
-	// space), but Linux only uses addresses above 1<<47 for
-	// mappings that explicitly pass a high hint address.
+	// See memLimitBits 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, there's not much we can do, so we just hope that
-	// the kernel doesn't get to really high addresses.
+	// 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
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index a397382291..f3e738116c 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -160,7 +160,24 @@ const (
 	//
 	// On 64-bit platforms, we limit this to 48 bits because that
 	// is the maximum supported by Linux across all 64-bit
-	// architectures, with the exception of s390x.
+	// architectures, with the exception of s390x. Based on
+	// processor.h:
+	//
+	// Architecture  Name              Maximum Value (exclusive)
+	// ---------------------------------------------------------------------
+	// amd64         TASK_SIZE_MAX     0x007ffffffff000 (47 bit addresses)
+	// arm64         TASK_SIZE_64      0x01000000000000 (48 bit addresses)
+	// ppc64{,le}    TASK_SIZE_USER64  0x00400000000000 (46 bit addresses)
+	// mips64{,le}   TASK_SIZE64       0x00010000000000 (40 bit addresses)
+	// s390x         TASK_SIZE         1<<64 (64 bit addresses)
+	//
+	// These values may increase over time. In particular, ppc64
+	// and mips64 support arbitrary 64-bit addresses in hardware,
+	// but Linux imposes the above limits. amd64 has hardware
+	// support for 57 bit addresses as of 2017 (56 bits for user
+	// space), but Linux only uses addresses above 1<<47 for
+	// mappings that explicitly pass a high hint address.
+	//
 	// s390x supports full 64-bit addresses, but the allocator
 	// will panic in the unlikely event we exceed 48 bits.
 	//