// Visit each goroutine that existed as of the startTheWorld call above.
	//
	// New goroutines may not be in this list, but we didn't want to know about
	// them anyway. If they do appear in this list (via reusing a dead goroutine
	// struct, or racing to launch between the world restarting and us getting
	// the list), they will already have their goroutineProfiled field set to

// means the word is a live pointer to be visited by the GC (referred to
// as "pointer"). A "0" bit means the word should be ignored by GC
// (referred to as "scalar", though it could be a dead pointer value).
//
// Heap bitmaps
//
// The heap bitmap comprises 1 bit for each pointer-sized word in the heap,
// recording whether a pointer is stored in that word or not. This bitmap

  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::mhlo::CreateInfeedsOpsXlaAdjustLayoutPass());

  if (lower_to_xla_hlo) {
    // This has to run after legalization to delete non legal but dead ops.
    // This must run before Shape Inference.
    pm.addNestedPass<mlir::func::FuncOp>(mlir::createCanonicalizerPass());

    // Run shape inference pass to propagate shapes through tensor_cast

on the socket to enable TCP Keepalives. properties: interval: description: The time duration between keep-alive probes. type: string probes: description: Maximum number of keepalive probes to send without response before deciding the connection is dead. type: integer time: description: The time duration a connection needs to be idle before keep-alive probes start being sent. type: string type: object type: object type: object loadBalancer: description: Settings controlling the load balancer algorithms....

	copy(slice2, slice1)
	return slice2[0]
}

func issue12397(x, y int) { // ERROR "moved to heap: y$"
	// x does not escape below, because all relevant code is dead.
	if false {
		gxx = &x
	} else {
		gxx = &y
	}

	if true {
		gxx = &y
	} else {
		gxx = &x
	}

	if p.As == obj.ACALL || p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ARET || p.As == obj.AJMP {
		// These opcodes don't use a GOT to access their argument (see rewriteToUseGot),
		// or R15 would be dead at them anyway.
		return false
	}
	if p.As == ALEAQ {
		// The GOT entry is placed directly in the destination register; R15 is not used.
		return false
	}

   resource is written later.

Assumption of this pass:
 . Compound resource operations have already been decomposed.
 . Dead functions have already been removed, as resource arguments in dead
   functions can cause the pass to fail.

#### Options
```
-functions : Comma separated list of functions whose resources read/writes should be promoted to function inputs/outputs.

	mp := getg().m

	// Emit a trace event for this syscall -> dead transition.
	//
	// N.B. the tracer can run on a bare M just fine, we just have
	// to make sure to do this before setg(nil) and unminit.
	var trace traceLocker
	if !mp.isExtraInSig {
		trace = traceAcquire()
	}

	// Return mp.curg to dead state.
	casgstatus(mp.curg, _Gsyscall, _Gdead)
	mp.curg.preemptStop = false

	MOVD	$runtime·mainPC(SB), R0		// entry
	SUB	$16, RSP
	MOVD	R0, 8(RSP) // arg
	MOVD	$0, 0(RSP) // dummy LR
	BL	runtime·newproc(SB)
	ADD	$16, RSP

	// start this M
	BL	runtime·mstart(SB)

	// Prevent dead-code elimination of debugCallV2 and debugPinnerV1, which are
	// intended to be called by debuggers.
	MOVD	$runtime·debugPinnerV1<ABIInternal>(SB), R0
	MOVD	$runtime·debugCallV2<ABIInternal>(SB), R0

	MOVD	$0, R0

	}
	return h.count
}

// mapinitnoop is a no-op function known the Go linker; if a given global
// map (of the right size) is determined to be dead, the linker will
// rewrite the relocation (from the package init func) from the outlined
// map init function to this symbol. Defined in assembly so as to avoid
// complications with instrumentation (coverage, etc).