runtime: update mkmalloc to make generated code look nicer

This cl adds a new operation that can remove an if statement or replace
it with its body if its condition is var or !var for some variable var
that's being replaced with a constant.

Change-Id: I864abf1f023b2a66b2299ca65d4f837d6a6a6964
Reviewed-on: https://go-review.googlesource.com/c/go/+/724940
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Michael Matloob <matloob@google.com>
Auto-Submit: Michael Matloob <matloob@google.com>

diff --git a/src/runtime/_mkmalloc/mkmalloc.go b/src/runtime/_mkmalloc/mkmalloc.go
index 46c50d6661116958ce50257c2c8887308735b88b..8032983da8c7324f7fea7c50143fdce49060bcff 100644 (file)
--- a/src/runtime/_mkmalloc/mkmalloc.go
+++ b/src/runtime/_mkmalloc/mkmalloc.go
@@ -107,6 +107,7 @@ type replacementKind int
 const (
        inlineFunc = replacementKind(iota)
        subBasicLit
+       foldCondition
 )
 
 // op is a single inlining operation for the inliner. Any calls to the function
@@ -171,7 +172,7 @@ func specializedMallocConfig(classes []class, sizeToSizeClass []uint8) generator
                                        {subBasicLit, "elemsize_", str(elemsize)},
                                        {subBasicLit, "sizeclass_", str(sc)},
                                        {subBasicLit, "noscanint_", str(noscan)},
-                                       {subBasicLit, "isTiny_", str(0)},
+                                       {foldCondition, "isTiny_", str(false)},
                                },
                        })
                }
@@ -199,7 +200,7 @@ func specializedMallocConfig(classes []class, sizeToSizeClass []uint8) generator
                                        {subBasicLit, "sizeclass_", str(tinySizeClass)},
                                        {subBasicLit, "size_", str(s)},
                                        {subBasicLit, "noscanint_", str(noscan)},
-                                       {subBasicLit, "isTiny_", str(1)},
+                                       {foldCondition, "isTiny_", str(true)},
                                },
                        })
                }
@@ -217,7 +218,7 @@ func specializedMallocConfig(classes []class, sizeToSizeClass []uint8) generator
                                        {subBasicLit, "elemsize_", str(elemsize)},
                                        {subBasicLit, "sizeclass_", str(sc)},
                                        {subBasicLit, "noscanint_", str(noscan)},
-                                       {subBasicLit, "isTiny_", str(0)},
+                                       {foldCondition, "isTiny_", str(false)},
                                },
                        })
                }
@@ -277,10 +278,17 @@ func inline(config generatorConfig) []byte {
                // Apply each of the ops given by the specs
                stamped := ast.Node(containingFuncCopy)
                for _, repl := range spec.ops {
-                       if toDecl, ok := funcDecls[repl.to]; ok {
-                               stamped = inlineFunction(stamped, repl.from, toDecl)
-                       } else {
+                       switch repl.kind {
+                       case inlineFunc:
+                               if toDecl, ok := funcDecls[repl.to]; ok {
+                                       stamped = inlineFunction(stamped, repl.from, toDecl)
+                               }
+                       case subBasicLit:
                                stamped = substituteWithBasicLit(stamped, repl.from, repl.to)
+                       case foldCondition:
+                               stamped = foldIfCondition(stamped, repl.from, repl.to)
+                       default:
+                               log.Fatal("unknown op kind %v", repl.kind)
                        }
                }
 
@@ -310,6 +318,43 @@ func substituteWithBasicLit(node ast.Node, from, to string) ast.Node {
        }, nil)
 }
 
+// foldIfCondition looks for if statements with a single boolean variable from, or
+// the negation of from and either replaces it with its body or nothing,
+// depending on whether the to value is true or false.
+func foldIfCondition(node ast.Node, from, to string) ast.Node {
+       var isTrue bool
+       switch to {
+       case "true":
+               isTrue = true
+       case "false":
+               isTrue = false
+       default:
+               log.Fatalf("op 'to' expr %q is not true or false", to)
+       }
+       return astutil.Apply(node, func(cursor *astutil.Cursor) bool {
+               var foldIfTrue bool
+               ifexpr, ok := cursor.Node().(*ast.IfStmt)
+               if !ok {
+                       return true
+               }
+               if isIdentWithName(ifexpr.Cond, from) {
+                       foldIfTrue = true
+               } else if unaryexpr, ok := ifexpr.Cond.(*ast.UnaryExpr); ok && unaryexpr.Op == token.NOT && isIdentWithName(unaryexpr.X, from) {
+                       foldIfTrue = false
+               } else {
+                       // not an if with from or !from.
+                       return true
+               }
+               if foldIfTrue == isTrue {
+                       for _, stmt := range ifexpr.Body.List {
+                               cursor.InsertBefore(stmt)
+                       }
+               }
+               cursor.Delete()
+               return true
+       }, nil)
+}
+
 // inlineFunction recursively replaces calls to the function 'from' with the body of the function
 // 'toDecl'. All calls to 'from' must appear in assignment statements.
 // The replacement is very simple: it doesn't substitute the arguments for the parameters, so the

diff --git a/src/runtime/malloc_generated.go b/src/runtime/malloc_generated.go
index 6864ca05d31901efa82fdb64ce4ea73c609462a0..cf329d26969e7fcfdcd7c8618cf18f092bdfb599 100644 (file)
--- a/src/runtime/malloc_generated.go
+++ b/src/runtime/malloc_generated.go
@@ -12,12 +12,6 @@ import (
 
 func mallocgcSmallScanNoHeaderSC1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -159,6 +153,7 @@ func mallocgcSmallScanNoHeaderSC1(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -182,12 +177,6 @@ func mallocgcSmallScanNoHeaderSC1(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -329,6 +318,7 @@ func mallocgcSmallScanNoHeaderSC2(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -352,12 +342,6 @@ func mallocgcSmallScanNoHeaderSC2(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -499,6 +483,7 @@ func mallocgcSmallScanNoHeaderSC3(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -522,12 +507,6 @@ func mallocgcSmallScanNoHeaderSC3(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -669,6 +648,7 @@ func mallocgcSmallScanNoHeaderSC4(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -692,12 +672,6 @@ func mallocgcSmallScanNoHeaderSC4(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -839,6 +813,7 @@ func mallocgcSmallScanNoHeaderSC5(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -862,12 +837,6 @@ func mallocgcSmallScanNoHeaderSC5(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -1009,6 +978,7 @@ func mallocgcSmallScanNoHeaderSC6(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -1032,12 +1002,6 @@ func mallocgcSmallScanNoHeaderSC6(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -1179,6 +1143,7 @@ func mallocgcSmallScanNoHeaderSC7(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -1202,12 +1167,6 @@ func mallocgcSmallScanNoHeaderSC7(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -1349,6 +1308,7 @@ func mallocgcSmallScanNoHeaderSC8(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -1372,12 +1332,6 @@ func mallocgcSmallScanNoHeaderSC8(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -1519,6 +1473,7 @@ func mallocgcSmallScanNoHeaderSC9(size uintptr, typ *_type, needzero bool) unsaf
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -1542,12 +1497,6 @@ func mallocgcSmallScanNoHeaderSC9(size uintptr, typ *_type, needzero bool) unsaf
 
 func mallocgcSmallScanNoHeaderSC10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -1689,6 +1638,7 @@ func mallocgcSmallScanNoHeaderSC10(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -1712,12 +1662,6 @@ func mallocgcSmallScanNoHeaderSC10(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -1859,6 +1803,7 @@ func mallocgcSmallScanNoHeaderSC11(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -1882,12 +1827,6 @@ func mallocgcSmallScanNoHeaderSC11(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -2029,6 +1968,7 @@ func mallocgcSmallScanNoHeaderSC12(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -2052,12 +1992,6 @@ func mallocgcSmallScanNoHeaderSC12(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -2199,6 +2133,7 @@ func mallocgcSmallScanNoHeaderSC13(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -2222,12 +2157,6 @@ func mallocgcSmallScanNoHeaderSC13(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -2369,6 +2298,7 @@ func mallocgcSmallScanNoHeaderSC14(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -2392,12 +2322,6 @@ func mallocgcSmallScanNoHeaderSC14(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -2539,6 +2463,7 @@ func mallocgcSmallScanNoHeaderSC15(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -2562,12 +2487,6 @@ func mallocgcSmallScanNoHeaderSC15(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC16(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -2709,6 +2628,7 @@ func mallocgcSmallScanNoHeaderSC16(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -2732,12 +2652,6 @@ func mallocgcSmallScanNoHeaderSC16(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC17(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -2879,6 +2793,7 @@ func mallocgcSmallScanNoHeaderSC17(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -2902,12 +2817,6 @@ func mallocgcSmallScanNoHeaderSC17(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC18(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -3049,6 +2958,7 @@ func mallocgcSmallScanNoHeaderSC18(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -3072,12 +2982,6 @@ func mallocgcSmallScanNoHeaderSC18(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC19(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -3219,6 +3123,7 @@ func mallocgcSmallScanNoHeaderSC19(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -3242,12 +3147,6 @@ func mallocgcSmallScanNoHeaderSC19(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC20(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -3389,6 +3288,7 @@ func mallocgcSmallScanNoHeaderSC20(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -3412,12 +3312,6 @@ func mallocgcSmallScanNoHeaderSC20(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC21(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -3559,6 +3453,7 @@ func mallocgcSmallScanNoHeaderSC21(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -3582,12 +3477,6 @@ func mallocgcSmallScanNoHeaderSC21(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC22(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -3729,6 +3618,7 @@ func mallocgcSmallScanNoHeaderSC22(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -3752,12 +3642,6 @@ func mallocgcSmallScanNoHeaderSC22(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC23(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -3899,6 +3783,7 @@ func mallocgcSmallScanNoHeaderSC23(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -3922,12 +3807,6 @@ func mallocgcSmallScanNoHeaderSC23(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC24(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4069,6 +3948,7 @@ func mallocgcSmallScanNoHeaderSC24(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -4092,12 +3972,6 @@ func mallocgcSmallScanNoHeaderSC24(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC25(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4239,6 +4113,7 @@ func mallocgcSmallScanNoHeaderSC25(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -4262,12 +4137,6 @@ func mallocgcSmallScanNoHeaderSC25(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocgcSmallScanNoHeaderSC26(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4409,6 +4278,7 @@ func mallocgcSmallScanNoHeaderSC26(size uintptr, typ *_type, needzero bool) unsa
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -4432,12 +4302,11 @@ func mallocgcSmallScanNoHeaderSC26(size uintptr, typ *_type, needzero bool) unsa
 
 func mallocTiny1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4489,11 +4358,6 @@ func mallocTiny1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -4576,11 +4440,6 @@ func mallocTiny1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -4599,12 +4458,11 @@ func mallocTiny1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4656,11 +4514,6 @@ func mallocTiny2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -4743,11 +4596,6 @@ func mallocTiny2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -4766,12 +4614,11 @@ func mallocTiny2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4823,11 +4670,6 @@ func mallocTiny3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -4910,11 +4752,6 @@ func mallocTiny3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -4933,12 +4770,11 @@ func mallocTiny3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -4990,11 +4826,6 @@ func mallocTiny4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -5077,11 +4908,6 @@ func mallocTiny4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -5100,12 +4926,11 @@ func mallocTiny4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -5157,11 +4982,6 @@ func mallocTiny5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -5244,11 +5064,6 @@ func mallocTiny5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -5267,12 +5082,11 @@ func mallocTiny5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -5324,11 +5138,6 @@ func mallocTiny6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -5411,11 +5220,6 @@ func mallocTiny6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -5434,12 +5238,11 @@ func mallocTiny6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -5491,11 +5294,6 @@ func mallocTiny7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -5578,11 +5376,6 @@ func mallocTiny7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -5601,12 +5394,11 @@ func mallocTiny7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -5658,11 +5450,6 @@ func mallocTiny8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -5745,11 +5532,6 @@ func mallocTiny8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -5768,12 +5550,11 @@ func mallocTiny8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -5825,11 +5606,6 @@ func mallocTiny9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -5912,11 +5688,6 @@ func mallocTiny9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -5935,12 +5706,11 @@ func mallocTiny9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -5992,11 +5762,6 @@ func mallocTiny10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -6079,11 +5844,6 @@ func mallocTiny10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -6102,12 +5862,11 @@ func mallocTiny10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -6159,11 +5918,6 @@ func mallocTiny11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -6246,11 +6000,6 @@ func mallocTiny11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -6269,12 +6018,11 @@ func mallocTiny11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -6326,11 +6074,6 @@ func mallocTiny12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -6413,11 +6156,6 @@ func mallocTiny12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -6436,12 +6174,11 @@ func mallocTiny12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -6493,11 +6230,6 @@ func mallocTiny13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -6580,11 +6312,6 @@ func mallocTiny13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -6603,12 +6330,11 @@ func mallocTiny13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -6660,11 +6386,6 @@ func mallocTiny14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -6747,11 +6468,6 @@ func mallocTiny14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -6770,12 +6486,11 @@ func mallocTiny14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocTiny15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 1 ==
-               1
        gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
+       if goexperiment.RuntimeSecret && gp.secret > 0 {
                return mallocgcSmallNoScanSC2(size, typ, needzero)
        }
+
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -6827,11 +6542,6 @@ func mallocTiny15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                const elemsize = 0
                {
 
-                       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-                               addSecret(x)
-                       }
-
                        if valgrindenabled {
                                valgrindMalloc(x, size)
                        }
@@ -6914,11 +6624,6 @@ func mallocTiny15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
                x = add(x, elemsize-constsize)
        }
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-
-               addSecret(x)
-       }
-
        if valgrindenabled {
                valgrindMalloc(x, size)
        }
@@ -6937,12 +6642,6 @@ func mallocTiny15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
 func mallocgcSmallNoScanSC2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -6984,6 +6683,7 @@ func mallocgcSmallNoScanSC2(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7054,6 +6754,7 @@ func mallocgcSmallNoScanSC2(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7077,12 +6778,6 @@ func mallocgcSmallNoScanSC2(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7124,6 +6819,7 @@ func mallocgcSmallNoScanSC3(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7194,6 +6890,7 @@ func mallocgcSmallNoScanSC3(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7217,12 +6914,6 @@ func mallocgcSmallNoScanSC3(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7264,6 +6955,7 @@ func mallocgcSmallNoScanSC4(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7334,6 +7026,7 @@ func mallocgcSmallNoScanSC4(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7357,12 +7050,6 @@ func mallocgcSmallNoScanSC4(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7404,6 +7091,7 @@ func mallocgcSmallNoScanSC5(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7474,6 +7162,7 @@ func mallocgcSmallNoScanSC5(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7497,12 +7186,6 @@ func mallocgcSmallNoScanSC5(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7544,6 +7227,7 @@ func mallocgcSmallNoScanSC6(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7614,6 +7298,7 @@ func mallocgcSmallNoScanSC6(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7637,12 +7322,6 @@ func mallocgcSmallNoScanSC6(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7684,6 +7363,7 @@ func mallocgcSmallNoScanSC7(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7754,6 +7434,7 @@ func mallocgcSmallNoScanSC7(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7777,12 +7458,6 @@ func mallocgcSmallNoScanSC7(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7824,6 +7499,7 @@ func mallocgcSmallNoScanSC8(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -7894,6 +7570,7 @@ func mallocgcSmallNoScanSC8(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -7917,12 +7594,6 @@ func mallocgcSmallNoScanSC8(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -7964,6 +7635,7 @@ func mallocgcSmallNoScanSC9(size uintptr, typ *_type, needzero bool) unsafe.Poin
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8034,6 +7706,7 @@ func mallocgcSmallNoScanSC9(size uintptr, typ *_type, needzero bool) unsafe.Poin
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8057,12 +7730,6 @@ func mallocgcSmallNoScanSC9(size uintptr, typ *_type, needzero bool) unsafe.Poin
 
 func mallocgcSmallNoScanSC10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8104,6 +7771,7 @@ func mallocgcSmallNoScanSC10(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8174,6 +7842,7 @@ func mallocgcSmallNoScanSC10(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8197,12 +7866,6 @@ func mallocgcSmallNoScanSC10(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8244,6 +7907,7 @@ func mallocgcSmallNoScanSC11(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8314,6 +7978,7 @@ func mallocgcSmallNoScanSC11(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8337,12 +8002,6 @@ func mallocgcSmallNoScanSC11(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8384,6 +8043,7 @@ func mallocgcSmallNoScanSC12(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8454,6 +8114,7 @@ func mallocgcSmallNoScanSC12(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8477,12 +8138,6 @@ func mallocgcSmallNoScanSC12(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8524,6 +8179,7 @@ func mallocgcSmallNoScanSC13(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8594,6 +8250,7 @@ func mallocgcSmallNoScanSC13(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8617,12 +8274,6 @@ func mallocgcSmallNoScanSC13(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8664,6 +8315,7 @@ func mallocgcSmallNoScanSC14(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8734,6 +8386,7 @@ func mallocgcSmallNoScanSC14(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8757,12 +8410,6 @@ func mallocgcSmallNoScanSC14(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8804,6 +8451,7 @@ func mallocgcSmallNoScanSC15(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -8874,6 +8522,7 @@ func mallocgcSmallNoScanSC15(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -8897,12 +8546,6 @@ func mallocgcSmallNoScanSC15(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC16(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -8944,6 +8587,7 @@ func mallocgcSmallNoScanSC16(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9014,6 +8658,7 @@ func mallocgcSmallNoScanSC16(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9037,12 +8682,6 @@ func mallocgcSmallNoScanSC16(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC17(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9084,6 +8723,7 @@ func mallocgcSmallNoScanSC17(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9154,6 +8794,7 @@ func mallocgcSmallNoScanSC17(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9177,12 +8818,6 @@ func mallocgcSmallNoScanSC17(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC18(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9224,6 +8859,7 @@ func mallocgcSmallNoScanSC18(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9294,6 +8930,7 @@ func mallocgcSmallNoScanSC18(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9317,12 +8954,6 @@ func mallocgcSmallNoScanSC18(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC19(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9364,6 +8995,7 @@ func mallocgcSmallNoScanSC19(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9434,6 +9066,7 @@ func mallocgcSmallNoScanSC19(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9457,12 +9090,6 @@ func mallocgcSmallNoScanSC19(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC20(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9504,6 +9131,7 @@ func mallocgcSmallNoScanSC20(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9574,6 +9202,7 @@ func mallocgcSmallNoScanSC20(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9597,12 +9226,6 @@ func mallocgcSmallNoScanSC20(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC21(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9644,6 +9267,7 @@ func mallocgcSmallNoScanSC21(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9714,6 +9338,7 @@ func mallocgcSmallNoScanSC21(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9737,12 +9362,6 @@ func mallocgcSmallNoScanSC21(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC22(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9784,6 +9403,7 @@ func mallocgcSmallNoScanSC22(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9854,6 +9474,7 @@ func mallocgcSmallNoScanSC22(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -9877,12 +9498,6 @@ func mallocgcSmallNoScanSC22(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC23(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -9924,6 +9539,7 @@ func mallocgcSmallNoScanSC23(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -9994,6 +9610,7 @@ func mallocgcSmallNoScanSC23(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -10017,12 +9634,6 @@ func mallocgcSmallNoScanSC23(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC24(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -10064,6 +9675,7 @@ func mallocgcSmallNoScanSC24(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -10134,6 +9746,7 @@ func mallocgcSmallNoScanSC24(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -10157,12 +9770,6 @@ func mallocgcSmallNoScanSC24(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC25(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -10204,6 +9811,7 @@ func mallocgcSmallNoScanSC25(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -10274,6 +9882,7 @@ func mallocgcSmallNoScanSC25(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)
@@ -10297,12 +9906,6 @@ func mallocgcSmallNoScanSC25(size uintptr, typ *_type, needzero bool) unsafe.Poi
 
 func mallocgcSmallNoScanSC26(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       const isTiny = 0 ==
-               1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
-       }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
                        throw("mallocgc called with gcphase == _GCmarktermination")
@@ -10344,6 +9947,7 @@ func mallocgcSmallNoScanSC26(size uintptr, typ *_type, needzero bool) unsafe.Poi
                x := v
                {
 
+                       gp := getg()
                        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                                addSecret(x)
@@ -10414,6 +10018,7 @@ func mallocgcSmallNoScanSC26(size uintptr, typ *_type, needzero bool) unsafe.Poi
                        gcStart(t)
                }
        }
+       gp := getg()
        if goexperiment.RuntimeSecret && gp.secret > 0 {
 
                addSecret(x)

diff --git a/src/runtime/malloc_stubs.go b/src/runtime/malloc_stubs.go
index 58ca1d5f79f805a9296505504a49ad896a928bdb..8c424935bf25c33727c2a36ec43ff1c05d305c45 100644 (file)
--- a/src/runtime/malloc_stubs.go
+++ b/src/runtime/malloc_stubs.go
@@ -37,7 +37,7 @@ const elemsize_ = 8
 const sizeclass_ = 0
 const noscanint_ = 0
 const size_ = 0
-const isTiny_ = 0
+const isTiny_ = false
 
 func malloc0(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        if doubleCheckMalloc {
@@ -58,15 +58,16 @@ func mallocPanic(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 // to steer out of this codepath early if sanitizers are enabled.
 func mallocStub(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 
-       // secret code, need to avoid the tiny allocator since it might keep
-       // co-located values alive longer and prevent timely zero-ing
-       //
-       // Call directly into the NoScan allocator.
-       // See go.dev/issue/76356
-       const isTiny = isTiny_ == 1
-       gp := getg()
-       if goexperiment.RuntimeSecret && isTiny && gp.secret > 0 {
-               return mallocgcSmallNoScanSC2(size, typ, needzero)
+       if isTiny_ {
+               // secret code, need to avoid the tiny allocator since it might keep
+               // co-located values alive longer and prevent timely zero-ing
+               //
+               // Call directly into the NoScan allocator.
+               // See go.dev/issue/76356
+               gp := getg()
+               if goexperiment.RuntimeSecret && gp.secret > 0 {
+                       return mallocgcSmallNoScanSC2(size, typ, needzero)
+               }
        }
        if doubleCheckMalloc {
                if gcphase == _GCmarktermination {
@@ -95,10 +96,13 @@ func mallocStub(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        // Actually do the allocation.
        x, elemsize := inlinedMalloc(size, typ, needzero)
 
-       if goexperiment.RuntimeSecret && gp.secret > 0 {
-               // Mark any object allocated while in secret mode as secret.
-               // This ensures we zero it immediately when freeing it.
-               addSecret(x)
+       if !isTiny_ {
+               gp := getg()
+               if goexperiment.RuntimeSecret && gp.secret > 0 {
+                       // Mark any object allocated while in secret mode as secret.
+                       // This ensures we zero it immediately when freeing it.
+                       addSecret(x)
+               }
        }
 
        // Notify valgrind, if enabled.