go tool covdata percent -i=data/goodexit
stdout  'coverage:.*[1-9][0-9.]+%'

# Program makes a direct call to os.Exit(1).
env GOCOVERDIR=data/badexit
! exec ./example.exe badexit
! stderr '^warning: GOCOVERDIR not set, no coverage data emitted'
go tool covdata percent -i=data/badexit
stdout  'coverage:.*[1-9][0-9.]+%'

# Program invokes panic.
env GOCOVERDIR=data/panic
! exec ./example.exe panic

var memprofilerateflag = flag.Int("memprofilerate", 0, "Set memprofile sampling rate to value")

var matchpkg func(name string) bool

var atExitFuncs []func()

func atExit(f func()) {
	atExitFuncs = append(atExitFuncs, f)
}

func Exit(code int) {
	for i := len(atExitFuncs) - 1; i >= 0; i-- {
		f := atExitFuncs[i]
		atExitFuncs = atExitFuncs[:i]
		f()
	}
	os.Exit(code)
}

package ld

import (
	"cmd/link/internal/loader"
	"encoding/binary"
	"fmt"
	"os"
)

var atExitFuncs []func()

func AtExit(f func()) {
	atExitFuncs = append(atExitFuncs, f)
}

// runAtExitFuncs runs the queued set of AtExit functions.
func runAtExitFuncs() {
	for i := len(atExitFuncs) - 1; i >= 0; i-- {
		atExitFuncs[i]()
	}
	atExitFuncs = nil
}

		{
			f:        func() { Fatal("Hello") },
			pat:      timePattern + "\tfatal\tHello",
			wantExit: true,
		},
		{
			f:        func() { Fatalf("Hello") },
			pat:      timePattern + "\tfatal\tHello",
			wantExit: true,
		},
		{
			f:        func() { Fatalf("%s", "Hello") },
			pat:      timePattern + "\tfatal\tHello",
			wantExit: true,
		},

		{
			f:      func() { Debug("Hello") },

	if logHeapTweaks {
		sample := append([]metrics.Sample(nil), sample...) // avoid races with GC callback
		AtExit(func() {
			metrics.Read(sample)
			goal := sample[GOAL].Value.Uint64()
			count := sample[COUNT].Value.Uint64()
			oldGogc := debug.SetGCPercent(100)
			if oldGogc == 100 {
				fmt.Fprintf(os.Stderr, "GCAdjust: AtExit goal %d gogc %d count %d maxprocs %d gcConcurrency %d\n",
					goal, oldGogc, count, mp, gcConcurrency)

};

void FlushAllListeners();

XlaActivityListenerList* GetXlaActivityListenerList() {
  static XlaActivityListenerList* listener_list = new XlaActivityListenerList;
  static int unused = std::atexit(FlushAllListeners);
  (void)unused;
  return listener_list;
}

template <typename FnTy>
Status ForEachListener(FnTy fn) {
  XlaActivityListenerList* listener_list = GetXlaActivityListenerList();

			expected string
			musthave []string
		}{
			{
				mode:     "simple",
				expected: "bar foo",
			},
			{
				mode:     "goodexit",
				expected: "orange apple",
			},
			{
				mode:     "badexit",
				expected: "blub blix",
			},
			{
				mode: "panics",
				musthave: []string{
					"fatal error: exit hook invoked panic",
					"main.testPanics",
				},
			},
			{
				mode: "callsexit",

	_ "unsafe"
)

var modeflag = flag.String("mode", "", "mode to run in")

func main() {
	flag.Parse()
	switch *modeflag {
	case "simple":
		testSimple()
	case "goodexit":
		testGoodExit()
	case "badexit":
		testBadExit()
	case "panics":
		testPanics()
	case "callsexit":
		testHookCallsExit()
	case "exit2":
		testExit2()
	default:
		panic("unknown mode")
	}
}

func testSimple() {

		generatorSyms: make(map[loader.Sym]generatorFunc),
	}

	if buildcfg.GOARCH != arch.Name {
		log.Fatalf("invalid buildcfg.GOARCH %s (want %s)", buildcfg.GOARCH, arch.Name)
	}

	AtExit(func() {
		if nerrors > 0 {
			ctxt.Out.ErrorClose()
			mayberemoveoutfile()
		}
	})

	return ctxt
}

// computeTLSOffset records the thread-local storage offset.

list [-json] [-broken]  list all supported platforms
test [-h]               run Go test(s)
version                 print Go version

All commands take -v flags to emit extra information.
`)
	xexit(2)
}

// commands records the available commands.
var commands = map[string]func(){
	"banner":    cmdbanner,
	"bootstrap": cmdbootstrap,
	"clean":     cmdclean,
	"env":       cmdenv,
	"install":   cmdinstall,