runtime: simplify needzero logic

We always need to zero allocations with pointers in them. So we don't
need some of the mallocs to take a needzero argument.

Change-Id: Ideaa7b738873ba6a93addb5169791b42e2baad7c
Reviewed-on: https://go-review.googlesource.com/c/go/+/660455
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Carlos Amedee <carlos@golang.org>

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index bb5f6b3c93bd2222373ee62300985463a84c5313..0a48f8bc61746e793477fd8f08529d2dbf62720a 100644 (file)
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -1047,14 +1047,19 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        if size <= maxSmallSize-mallocHeaderSize {
                if typ == nil || !typ.Pointers() {
                        if size < maxTinySize {
-                               x, elemsize = mallocgcTiny(size, typ, needzero)
+                               x, elemsize = mallocgcTiny(size, typ)
                        } else {
                                x, elemsize = mallocgcSmallNoscan(size, typ, needzero)
                        }
-               } else if heapBitsInSpan(size) {
-                       x, elemsize = mallocgcSmallScanNoHeader(size, typ, needzero)
                } else {
-                       x, elemsize = mallocgcSmallScanHeader(size, typ, needzero)
+                       if !needzero {
+                               throw("objects with pointers must be zeroed")
+                       }
+                       if heapBitsInSpan(size) {
+                               x, elemsize = mallocgcSmallScanNoHeader(size, typ)
+                       } else {
+                               x, elemsize = mallocgcSmallScanHeader(size, typ)
+                       }
                }
        } else {
                x, elemsize = mallocgcLarge(size, typ, needzero)
@@ -1092,7 +1097,7 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        return x
 }
 
-func mallocgcTiny(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
+func mallocgcTiny(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
        // Set mp.mallocing to keep from being preempted by GC.
        mp := acquirem()
        if doubleCheckMalloc {
@@ -1172,7 +1177,7 @@ func mallocgcTiny(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uint
                v, span, checkGCTrigger = c.nextFree(tinySpanClass)
        }
        x := unsafe.Pointer(v)
-       (*[2]uint64)(x)[0] = 0
+       (*[2]uint64)(x)[0] = 0 // Always zero
        (*[2]uint64)(x)[1] = 0
        // See if we need to replace the existing tiny block with the new one
        // based on amount of remaining free space.
@@ -1334,7 +1339,7 @@ func mallocgcSmallNoscan(size uintptr, typ *_type, needzero bool) (unsafe.Pointe
        return x, size
 }
 
-func mallocgcSmallScanNoHeader(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
+func mallocgcSmallScanNoHeader(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
        // Set mp.mallocing to keep from being preempted by GC.
        mp := acquirem()
        if doubleCheckMalloc {
@@ -1363,7 +1368,7 @@ func mallocgcSmallScanNoHeader(size uintptr, typ *_type, needzero bool) (unsafe.
                v, span, checkGCTrigger = c.nextFree(spc)
        }
        x := unsafe.Pointer(v)
-       if needzero && span.needzero != 0 {
+       if span.needzero != 0 {
                memclrNoHeapPointers(x, size)
        }
        if goarch.PtrSize == 8 && sizeclass == 1 {
@@ -1425,7 +1430,7 @@ func mallocgcSmallScanNoHeader(size uintptr, typ *_type, needzero bool) (unsafe.
        return x, size
 }
 
-func mallocgcSmallScanHeader(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
+func mallocgcSmallScanHeader(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
        // Set mp.mallocing to keep from being preempted by GC.
        mp := acquirem()
        if doubleCheckMalloc {
@@ -1461,7 +1466,7 @@ func mallocgcSmallScanHeader(size uintptr, typ *_type, needzero bool) (unsafe.Po
                v, span, checkGCTrigger = c.nextFree(spc)
        }
        x := unsafe.Pointer(v)
-       if needzero && span.needzero != 0 {
+       if span.needzero != 0 {
                memclrNoHeapPointers(x, size)
        }
        header := (**_type)(x)