// error. Currently, the reader code doesn't verify the
		// fileheader and TOC's crc32 match if they're both
		// non-zero and only the second line above, the TOC,
		// is what matters.
	})
}

// rZipBytes returns the bytes of a recursive zip file, without
// putting it on disk and triggering certain virus scanners.
func rZipBytes() []byte {
	s := `

		"test.nestedCall.func1",
		"test.nestedCall",
		"test.testCallbackCallers",
		"test.TestCallbackCallers",
		"testing.tRunner",
		"runtime.goexit",
	}
	nestedCall(func() {
		n = runtime.Callers(4, pc)
	})
	if n != len(name) {
		t.Errorf("expected %d frames, got %d", len(name), n)
	}
	for i := 0; i < n; i++ {
		f := runtime.FuncForPC(pc[i] - 1) // TODO: use runtime.CallersFrames
		if f == nil {

<li>
<code>recover</code> was not called directly by a deferred function.
</li>
</ul>

<p>
The <code>protect</code> function in the example below invokes
the function argument <code>g</code> and protects callers from
run-time panics raised by <code>g</code>.
</p>

<pre>
func protect(g func()) {
	defer func() {
		log.Println("done")  // Println executes normally even if there is a panic

causes a <a href="#Run_time_panics">run-time panic</a>.
</p>

<p>
The <code>protect</code> function in the example below invokes
the function argument <code>g</code> and protects callers from
run-time panics raised by <code>g</code>.
</p>

<pre>
func protect(g func()) {
	defer func() {
		log.Println("done")  // Println executes normally even if there is a panic

pkg debug/elf, const EM_78KOR = 199
pkg debug/elf, const EM_78KOR Machine
pkg debug/elf, const EM_8051 = 165
pkg debug/elf, const EM_8051 Machine
pkg debug/elf, const EM_ALTERA_NIOS2 = 113
pkg debug/elf, const EM_ALTERA_NIOS2 Machine
pkg debug/elf, const EM_AMDGPU = 224
pkg debug/elf, const EM_AMDGPU Machine
pkg debug/elf, const EM_ARCA = 109
pkg debug/elf, const EM_ARCA Machine
pkg debug/elf, const EM_ARC_COMPACT = 93

// the file it describes, it may be necessary to modify the Name field
// of the returned header to provide the full path name of the file.
// If compression is desired, callers should set the FileHeader.Method
// field; it is unset by default.
func FileInfoHeader(fi fs.FileInfo) (*FileHeader, error) {
	size := fi.Size()
	fh := &FileHeader{
		Name:               fi.Name(),

func (rc *ReadCloser) Close() error {
	return rc.f.Close()
}

// DataOffset returns the offset of the file's possibly-compressed
// data, relative to the beginning of the zip file.
//
// Most callers should instead use [File.Open], which transparently
// decompresses data and verifies checksums.
func (f *File) DataOffset() (offset int64, err error) {
	bodyOffset, err := f.findBodyOffset()
	if err != nil {
		return

Also, constants are always evaluated as 64-bit unsigned integers.
Thus <code>-2</code> is not the integer value minus two,
but the unsigned 64-bit integer with the same bit pattern.
The distinction rarely matters but
to avoid ambiguity, division or right shift where the right operand's
high bit is set is rejected.
</p>

<h3 id="symbols">Symbols</h3>

<p>
Some symbols, such as <code>R1</code> or <code>LR</code>,

pkg runtime, const GOARCH string
pkg runtime, const GOOS string
pkg runtime, func Breakpoint()
pkg runtime, func CPUProfile() []uint8
pkg runtime, func Caller(int) (uintptr, string, int, bool)
pkg runtime, func Callers(int, []uintptr) int
pkg runtime, func FuncForPC(uintptr) *Func
pkg runtime, func GC()
pkg runtime, func GOMAXPROCS(int) int
pkg runtime, func GOROOT() string
pkg runtime, func Goexit()

		}
		nextFiles = next
	}

	for _, c := range contexts {
		c.Compiler = build.Default.Compiler
	}

	walkers := make([]*Walker, len(contexts))
	var wg sync.WaitGroup
	for i, context := range contexts {
		i, context := i, context
		wg.Add(1)
		go func() {
			defer wg.Done()
			walkers[i] = NewWalker(context, filepath.Join(testenv.GOROOT(t), "src"))
		}()
	}
	wg.Wait()