return
	}

	relocs := ldr.Relocs(s)
	r := relocs.At(ri)
	var t int64
	// ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
	// laid out. Conservatively use a trampoline. This should be rare, as we lay out packages
	// in dependency order.
	if ldr.SymValue(rs) != 0 {
		t = ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
	}
	switch r.Type() {

// This is ABIInternal because Go code injects its PC directly into new
// goroutine stacks.
TEXT runtime·debugCallV2<ABIInternal>(SB),NOSPLIT,$152-0
	// Save all registers that may contain pointers so they can be
	// conservatively scanned.
	//
	// We can't do anything that might clobber any of these
	// registers before this.
	MOVQ	R15, r15-(14*8+8)(SP)
	MOVQ	R14, r14-(13*8+8)(SP)
	MOVQ	R13, r13-(12*8+8)(SP)

  # Set queue_full action to block because we want to pause gracefully
  # in case of the off-the-limits load instead of throwing an exception
  buffer_queue_full_action block
  # Set the chunk limit conservatively to avoid exceeding the recommended
  # chunk size of 5MB per write request.
  buffer_chunk_limit 512k
  # Cap the combined memory usage of this buffer and the one below to
  # 512KiB/chunk * (6 + 2) chunks = 4 MiB

  // refines the element shape if all tensors written to the list across all
  // mutations have identical static shape.
  bool InferShapeForTensorListInitOps(Operation* op);

  // Conservatively infers shape of output tenorlist and item based on
  // input tensorlist's element shape.
  bool InferShapeForTensorListPopBackOp(TensorListPopBackOp op);

    if (tensor_info.has_tensor_shape()) {
      array_info.shape = tensor_info.tensor_shape();
    } else {
      // If there is no tensor shape in the tensor info, conservatively set
      // unknown_rank to true.
      array_info.shape.set_unknown_rank(true);
    }

    results.insert(std::pair<std::string, ArrayInfo>(std::move(name),

//    (note that returning `std::nullopt` here signals exactly that).
// 3) If `is_stateless` is false and no ordering token is present, then we treat
//    the op conservatively which means that different op instances need
//    dependencies. This is realized by always returning the same string ("")
//    in this case. In fact, we could return any string here, as long as it is

// license that can be found in the LICENSE file.

package sys

// ExecArgLengthLimit is the number of bytes we can safely
// pass as arguments to an exec.Command.
//
// Windows has a limit of 32 KB. To be conservative and not worry about whether
// that includes spaces or not, just use 30 KB. Darwin's limit is less clear.
// The OS claims 256KB, but we've seen failures with arglen as small as 50KB.

package escape

type S struct {
	i  int
	pi *int
}

var sink S

func f(p *S) { // ERROR "leaking param: p"
	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

		func() {
			f1()
		}()
	}
	runtime.SetFinalizer(&f1, func(f *func()) {
		atomic.AddInt64(&count, -1)
	})
	go f2()
	return nil
}

func main() {
	// Does not work with gccgo, due to partially conservative GC.
	// Try to enable when we have fully precise GC.
	if runtime.Compiler == "gccgo" {
		return
	}
	count = N
	var wg sync.WaitGroup
	wg.Add(N)
	for i := 0; i < N; i++ {
		go func() {
			run()

package main

import (
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

var sink func()

func main() {
	// Does not work with gccgo, due to partially conservative GC.
	// Try to enable when we have fully precise GC.
	if runtime.Compiler == "gccgo" {
		return
	}
	N := 10
	count := int32(N)
	var wg sync.WaitGroup
	wg.Add(N)
	for i := 0; i < N; i++ {
		go func() {