panic("did not panic")
		}
		var pcs [10]uintptr
		n := runtime.Callers(1, pcs[:])
		iter := runtime.CallersFrames(pcs[:n])
		buf := ""
		for {
			frame, more := iter.Next()
			buf += fmt.Sprintf("%s:%d %s\n", frame.File, frame.Line, frame.Function)
			if !more {
				break
			}
		}
		if !strings.Contains(buf, "999999") {
			fmt.Printf("could not find marker line in traceback:\n%s\n", buf)
			bad = true

	TLSBSS = 256

	// Do not insert instructions to allocate a stack frame for this function.
	// Only valid on functions that declare a frame size of 0.
	// TODO(mwhudson): only implemented for ppc64x at present.
	NOFRAME = 512

	// Function can call reflect.Type.Method or reflect.Type.MethodByName.
	REFLECTMETHOD = 1024

	// Function is the outermost frame of the call stack. Call stack unwinders
	// should stop at this function.

	// and that we see TestTracebackSystemstack.
	countIn, countOut := 0, 0
	frames := CallersFrames(pcs)
	var tb strings.Builder
	for {
		frame, more := frames.Next()
		fmt.Fprintf(&tb, "\n%s+0x%x %s:%d", frame.Function, frame.PC-frame.Entry, frame.File, frame.Line)
		switch frame.Function {
		case "runtime.TracebackSystemstack":
			countIn++
		case "runtime_test.TestTracebackSystemstack":

		l.IsFolded = false
		for i, frame := range stack {
			if frame.Func != "" {
				m.HasFunctions = true
			}
			if frame.File != "" {
				m.HasFilenames = true
			}
			if frame.Line != 0 {
				m.HasLineNumbers = true
			}
			f := addFunction(&profile.Function{
				Name:       frame.Func,
				SystemName: frame.Func,
				Filename:   frame.File,
			})
			l.Line[i] = profile.Line{

// FIXED_FRAME defines the size of the fixed part of a stack frame. A stack
// frame looks like this:
//
// +---------------------+
// | local variable area |
// +---------------------+
// | argument area       |
// +---------------------+ <- R1+FIXED_FRAME
// | fixed area          |
// +---------------------+ <- R1
//
// So a function that sets up a stack frame at all uses as least FIXED_FRAME

// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
	// Start with standard C stack frame layout and linkage.

	// Save R6-R15 in the register save area of the calling function.
	STMG	R6, R15, 48(R15)

	// Allocate 96 bytes on the stack.
	MOVD	$-96(R15), R15

	// Save F8-F15 in our stack frame.
	FMOVD	F8, 32(R15)
	FMOVD	F9, 40(R15)
	FMOVD	F10, 48(R15)
	FMOVD	F11, 56(R15)

#
# 64-bit systems do not attempt to execute test cases with frame sizes
# that are only 32-bit aligned.

# Ordinary function should work
start 0

# Large frame marked nosplit is always wrong.
# Frame is so large it overflows cmd/link's int16.
start 100000 nosplit
REJECT

# Calling a large frame is okay.
start 0 call big
big 10000

# But not if the frame is nosplit.
start 0 call big
big 10000 nosplit
REJECT

    StackFramePredicate USER_CODE = new StackFramePredicate() {
        @Override
        public boolean test(StackTraceElement frame, StackTraceRelevance relevance) {
            return StackTraceRelevance.USER_CODE.equals(relevance);
        }
    };

    boolean test(StackTraceElement frame, StackTraceRelevance relevance);

        }

        // Write a frame.
        val length = (end - start).toInt()
        outputStream.write(outBytes, start.toInt(), length)

        // If the last frame was truncated, immediately close the connection.
        if (truncated) {
          socket.close()
        }
      } else {
        // read a frame
        val inFrame = InFrame(i, reader)
        reader.nextFrame(false, inFrame)

	for stack, record := range m.stacks {
		rec := *record
		i := 0
		stack.Frames(func(frame trace.StackFrame) bool {
			rec.Stack = append(rec.Stack, &trace.Frame{
				PC:   frame.PC,
				Fn:   frame.Func,
				File: frame.File,
				Line: int(frame.Line),
			})
			i++
			// Cut this off at pprofMaxStack because that's as far
			// as our deduplication goes.