// Test walk errors for not-in-heap.

//go:build cgo

package p

import "runtime/cgo"

type nih struct {
	_    cgo.Incomplete
	next *nih
}

// Global variables are okay.

var x nih

// Stack variables are not okay.

func f() {
	var y nih // ERROR "nih is incomplete \(or unallocatable\); stack allocation disallowed"
	x = y
}

// Heap allocation is not okay.

var y *nih

// This test makes sure that naming named
// return variables in a return statement works.
// See issue #14904.

package main

import (
	"runtime"
	"testing"
)

// Our heap-allocated object that will be GC'd incorrectly.
// Note that we always check the second word because that's
// where 0xdeaddeaddeaddead is written.
type B [4]int

// small (SSAable) array
type A1 [3]*B

		if i == 0 {
			return x
		}
	}
	return nil
}

var sink *uint64

func main() {
	var a1, a2 A
	var b1, b2, b3, b4 B
	var x1, x2, x3, x4 uint64 // ERROR "moved to heap: x1" "moved to heap: x3"
	b1.b[0] = &x1
	b2.b[0] = &x2
	b3.b[0] = &x3
	b4.b[0] = &x4
	f(a1)
	g(&a2)
	sink = h(&b1)
	h(&b2)
	sink = h2(&b1)
	h2(&b4)
	x1 = 17

//   but is critical when allocating new spans. The entry point for
//   this is mheap_.reclaim and it's driven by a sequential scan of
//   the page marks bitmap in the heap arenas.
//
// Both algorithms ultimately call mspan.sweep, which sweeps a single
// heap span.

package runtime

import (
	"internal/abi"
	"internal/runtime/atomic"
	"unsafe"
)

var sweep sweepdata

// State of background sweep.

        clientsManager.selectIdleClientsToStop(selector);
        return selector.getReleasedBytes();
    }

    /**
     * Simple implementation of memory based expiration.
     *
     * Use the maximum heap size of each daemon, not their actual memory usage.
     * Expire as much daemons as needed to free the requested memory under the threshold.
     */

package runtime

// osStackAlloc performs OS-specific initialization before s is used
// as stack memory.
func osStackAlloc(s *mspan) {
}

// osStackFree undoes the effect of osStackAlloc before s is returned
// to the heap.
func osStackFree(s *mspan) {

	// TODO(mdempsky): What about fieldAlign?
	if elem.Pointers() && uintptr(p)&(uintptr(elem.Align_)-1) != 0 {
		throw("checkptr: misaligned pointer conversion")
	}

	// Check that (*[n]elem)(p) doesn't straddle multiple heap objects.
	// TODO(mdempsky): Fix #46938 so we don't need to worry about overflow here.
	if checkptrStraddles(p, n*elem.Size_) {
		throw("checkptr: converted pointer straddles multiple allocations")
	}
}

package main

import _ "./linkname1"
import "./linkname2"

func main() { // ERROR "can inline main"
	str := "hello/world"
	bs := []byte(str)        // ERROR "\(\[\]byte\)\(str\) escapes to heap"
	if y.ContainsSlash(bs) { // ERROR "inlining call to y.ContainsSlash"
	}

	if m.gc == GC {
		runtime.GC()
		runtime.ReadMemStats(&m.curMark.gcM)
		if m.shouldPProf() {
			// Collect a profile of the live heap. Do a
			// second GC to force sweep completion so we
			// get a complete snapshot of the live heap at
			// the end of this phase.
			runtime.GC()
			f, err := os.Create(makePProfFilename(m.filebase, m.curMark.name, "memprof"))
			if err != nil {
				panic(err)

Daemons use the JVM's default minimum heap size.

If the requested build environment does not specify a maximum heap size, the Daemon uses up to 512MB of heap.
512MB is adequate for most builds.
Larger builds with hundreds of subprojects, configuration, and source code may benefit from a larger heap size.

[[sec:status]]
== Check Daemon status