p.pi = &p.i
	sink = *p
}

// BAD: "leaking param: p" is too conservative
func g(p *S) { // ERROR "leaking param: p"
	p.pi = &p.i
}

func h() {
	var s S // ERROR "moved to heap: s"
	g(&s)
	sink = s

		panicunsafestringlen()
	}
	unsafestring(ptr, len)
}

func unsafestringcheckptr(ptr unsafe.Pointer, len64 int64) {
	unsafestring64(ptr, len64)

	// Check that underlying array doesn't straddle multiple heap objects.
	// unsafestring64 has already checked for overflow.
	if checkptrStraddles(ptr, uintptr(len64)) {
		throw("checkptr: unsafe.String result straddles multiple allocations")
	}
}

func panicunsafestringlen() {

//
// This stack is intrusive. Nodes must embed lfnode as the first field.
//
// The stack does not keep GC-visible pointers to nodes, so the caller
// must ensure the nodes are allocated outside the Go heap.
type lfstack uint64

func (head *lfstack) push(node *lfnode) {
	node.pushcnt++
	new := lfstackPack(node, node.pushcnt)
	if node1 := lfstackUnpack(new); node1 != node {

In general, types that are allocated using any of these should be
marked as not in heap by embedding `runtime/internal/sys.NotInHeap`.

Objects that are allocated in unmanaged memory **must not** contain
heap pointers unless the following rules are also obeyed:

1. Any pointers from unmanaged memory to the heap must be garbage
   collection roots. More specifically, any pointer must either be

*   Fixes a heap OOB read in `tf.ragged.cross`
    ([CVE-2021-41212](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41212))
*   Fixes a heap OOB in shape inference for `QuantizeV2`
    ([CVE-2021-41211](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41211))
*   Fixes a heap OOB read in all `tf.raw_ops.QuantizeAndDequantizeV*` ops

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types2

import (
	"container/heap"
	"fmt"
	. "internal/types/errors"
	"sort"
)

// initOrder computes the Info.InitOrder for package variables.
func (check *Checker) initOrder() {
	// An InitOrder may already have been computed if a package is

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types

import (
	"container/heap"
	"fmt"
	. "internal/types/errors"
	"sort"
)

// initOrder computes the Info.InitOrder for package variables.
func (check *Checker) initOrder() {
	// An InitOrder may already have been computed if a package is

            )
          |||
        ),
        self.query(
          'Heap (In Use) ({{pod}})',
          |||
            sum by (pod) (
              go_memstats_heap_inuse_bytes{%(appLabels)s}
            )
          |||
        ),
        self.query(
          'Heap (Allocated) ({{pod}})',
          |||
            sum by (pod) (

func heapObjectsCanMove() bool

func TestHeapObjectsCanMove(t *testing.T) {
	if heapObjectsCanMove() {
		// If this happens (or this test stops building),
		// it will break go4.org/unsafe/assume-no-moving-gc.
		t.Fatalf("heap objects can move!")
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test write barrier for implicit assignments to result parameters
// that have escaped to the heap.

package issue13587

import "errors"

func escape(p *error)

func F() (err error) {
	escape(&err)
	return errors.New("error") // ERROR "write barrier"