// Started running while doing GC things.
					ps[ev.Proc()].gc++
				} else if old.Executing() && !new.Executing() {
					// Stopped running while doing GC things.
					ps[ev.Proc()].gc--
				}
			}
			states[g] = new
		case EventLabel:
			l := ev.Label()
			if flags&UtilBackground != 0 && strings.HasPrefix(l.Label, "GC ") && l.Label != "GC (idle)" {
				// Background mark worker.
				//

package main

import "runtime"

func mk2() {
	b := new([10000]byte)
	_ = b
	//	println(b, "stored at", &b)
}

func mk1() { mk2() }

func main() {
	for i := 0; i < 10; i++ {
		mk1()
		runtime.GC()
	}

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

//go:build gc

package goroot

import (
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"
)

// IsStandardPackage reports whether path is a standard package,
// given goroot and compiler.
func IsStandardPackage(goroot, compiler, path string) bool {
	switch compiler {
	case "gc":
		dir := filepath.Join(goroot, "src", path)

func DeferLiveness() {
	var x [10]int
	escape(&x)
	fn := func() {
		if x[0] != 42 {
			panic("FAIL")
		}
	}
	defer fn()

	x[0] = 42
	runtime.GC()
	runtime.GC()
	runtime.GC()
}

//go:noinline
func escape(x any) { sink2 = x; sink2 = nil }

var sink2 any

// Test zombie object detection and reporting.
func GCZombie() {

// Copyright 2018 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.

//go:build gc

package build

import (
	"path/filepath"
	"runtime"
)

// getToolDir returns the default value of ToolDir.
func getToolDir() string {
	return filepath.Join(runtime.GOROOT(), "pkg/tool/"+runtime.GOOS+"_"+runtime.GOARCH)

	ppath := p.ImportPath
	if cfg.BuildBuildmode == "plugin" {
		ppath = pluginPath(a)
	} else if p.Name == "main" && !p.Internal.ForceLibrary {
		ppath = "main"
	}
	return ppath
}

func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, pgoProfile string, gofiles []string) (ofile string, output []byte, err error) {
	p := a.Package
	sh := b.Shell(a)
	objdir := a.Objdir

// Copyright 2023 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.

// Tests a GC-heavy program. This is useful for shaking out
// all sorts of corner cases about GC-related ranges.

//go:build ignore

package main

import (
	"log"
	"os"
	"runtime"
	"runtime/trace"
	"time"
)

type node struct {
	children [4]*node

	pc=4804475 func=32 file=33 line=60
EventBatch gen=3 m=18446744073709551615 time=28114950894688 size=2762
Strings
String id=1
	data="Not worker"
String id=2
	data="GC (dedicated)"
String id=3
	data="GC (fractional)"
String id=4
	data="GC (idle)"
String id=5
	data="unspecified"
String id=6
	data="forever"
String id=7
	data="network"
String id=8
	data="select"
String id=9

	x       string
	matched bool
	err     error
}{
	{"gc", true, nil},
	{"gccgo", false, nil},
	{"!gc", false, nil},
	{"gc && gccgo", false, nil},
	{"gc || gccgo", true, nil},
	{"gc || (gccgo && !gccgo)", true, nil},
	{"gc && (gccgo || !gccgo)", true, nil},
	{"!(gc && (gccgo || !gccgo))", false, nil},
	{"gccgo || gc", true, nil},
	{"!(!(!(gccgo || gc)))", false, nil},
	{"compiler_bootstrap", false, nil},

	"runtime"
)

type HeapObj [8]int64

type StkObj struct {
	h *HeapObj
}

var n int
var c int = -1

func gc() {
	// encourage heap object to be collected, and have its finalizer run.
	runtime.GC()
	runtime.GC()
	runtime.GC()
	n++
}

func main() {
	f()
	gc() // prior to stack objects, heap object is not collected until here
	if c < 0 {
		panic("heap object never collected")
	}
	if c != 1 {