for _, f := range a.File {
		writeUint32(uint32(f))
	}
	writeUint32(uint32(len(a.InlTree)))
	for i := range a.InlTree {
		a.InlTree[i].Write(w)
	}
}

// FuncInfoLengths is a cache containing a roadmap of offsets and
// lengths for things within a serialized FuncInfo. Each length field
// stores the number of items (e.g. files, inltree nodes, etc), and the
// corresponding "off" field stores the byte offset of the start of

//
// Eventually, the compiler extracts a per-function inlining tree from
// the global inlining tree (see pcln.go).
type InlTree struct {
	nodes []InlinedCall
}

// InlinedCall is a node in an InlTree.
type InlinedCall struct {
	Parent   int      // index of the parent in the InlTree or < 0 if outermost call
	Pos      src.XPos // position of the inlined call
	Func     *LSym    // function that was inlined

	inldata := funcdata(f, abi.FUNCDATA_InlTree)
	if inldata == nil {
		return inlineUnwinder{f: f}, inlineFrame{pc: pc, index: -1}
	}
	inlTree := (*[1 << 20]inlinedCall)(inldata)
	u := inlineUnwinder{f: f, inlTree: inlTree}
	return u, u.resolveInternal(pc)
}

func (u *inlineUnwinder) resolveInternal(pc uintptr) inlineFrame {
	return inlineFrame{
		pc: pc,

		t.Errorf("Name() = %q, want %q", got, "")
	}
}

var dummy int

func inlined() {
	// Side effect to prevent elimination of this entire function.
	dummy = 42
}

// A function with an InlTree. Returns a PC within the function body.
//
// No inline to ensure this complete function appears in output.
//
//go:noinline
func tracebackFunc(t *testing.T) uintptr {