if gp.lockedm == 0 {
		return nil, plainError("goroutine not locked to thread")
	}

	tid := int(gp.lockedm.ptr().procid)
	if tid == 0 {
		return nil, plainError("missing tid")
	}

	f := efaceOf(&fn)
	if f._type == nil || f._type.Kind_&abi.KindMask != abi.Func {
		return nil, plainError("fn must be a function")
	}

		ts = w.traceBuf.lastTime + 1
	}
	w.traceBuf.lastTime = ts
	w.traceBuf.link = nil
	w.traceBuf.pos = 0

	// Tolerate a nil mp.
	mID := ^uint64(0)
	if w.mp != nil {
		mID = uint64(w.mp.procid)
	}

	// Write the buffer's header.
	if exp == traceNoExperiment {
		w.byte(byte(traceEvEventBatch))
	} else {
		w.byte(byte(traceEvExperimentalBatch))
		w.byte(byte(exp))
	}

			go121Events: convertOldFormat(tr),
		}, nil
	case version.Go122, version.Go123:
		return &Reader{
			r: br,
			order: ordering{
				mStates:     make(map[ThreadID]*mState),
				pStates:     make(map[ProcID]*pState),
				gStates:     make(map[GoID]*gState),
				activeTasks: make(map[TaskID]taskState),
			},
			// Don't emit a sync event when we first go to emit events.
			emittedSync: true,
		}, nil
	default:

		w = w.writeProcStatus(uint64(pp.id), procStatus, pp.trace.inSweep)
	}
	if gp := tl.mp.curg; gp != nil && !gp.trace.statusWasTraced(tl.gen) && gp.trace.acquireStatus(tl.gen) {
		w = w.writeGoStatus(uint64(gp.goid), int64(tl.mp.procid), goStatus, gp.inMarkAssist, 0 /* no stack */)
	}
	return traceEventWriter{w}
}

// commit writes out a trace event and calls end. It's a helper to make the

	case "gstatus":
		u = uint64(arg.(go122.GoStatus))
	case "g":
		u = uint64(arg.(trace.GoID))
	case "m":
		u = uint64(arg.(trace.ThreadID))
	case "p":
		u = uint64(arg.(trace.ProcID))
	case "string":
		u = b.gen.String(arg.(string))
	case "task":
		u = uint64(arg.(trace.TaskID))
	default:
		panic(fmt.Sprintf("unsupported arg type %q for spec %q", typStr, argSpec))
	}
	return u
}

		hi := g0.stack.hi
		lo := g0.stack.lo
		g0.stack.hi = sp + 1024
		g0.stack.lo = sp - 32*1024
		g0.stackguard0 = g0.stack.lo + stackGuard
		g0.stackguard1 = g0.stackguard0

		print("M ", mp.id, " procid ", mp.procid, " runtime: cgocallback with sp=", hex(sp), " out of bounds [", hex(lo), ", ", hex(hi), "]")
		print("\n")
		exit(2)
	}

	if !mp.isextra {
		// We allocated the stack for standard Ms. Don't replace the

		if err != nil {
			return nil, err
		}
		mid := ThreadID(m)

		// Read the sample's P.
		p, err := binary.ReadUvarint(r)
		if err != nil {
			return nil, err
		}
		pid := ProcID(p)

		// Read the sample's G.
		g, err := binary.ReadUvarint(r)
		if err != nil {
			return nil, err
		}
		goid := GoID(g)
		if g == 0 {
			goid = NoGoroutine
		}

	// Check that SP is as we expect
	NOP	R29	// tell vet R29/SP changed - stop checking offsets
	MOVW	12(R29), R16
	MOVW	$1234, R1
	BEQ	R16, R1, 2(PC)
	MOVW	(R0), R0

	// Initialize m->procid to Linux tid
	MOVW	$SYS_gettid, R2
	SYSCALL

	MOVW	0(R29), R16	// m
	MOVW	4(R29), R17	// g
	MOVW	8(R29), R18	// fn

	BEQ	R16, nog
	BEQ	R17, nog

	MOVW	R2, m_procid(R16)

	// In parent, return.
	BEQ	R2, 3(PC)
	MOVW	R2, ret+40(FP)
	RET

	// In child, on new stack.
	MOVV	-32(R29), R16
	MOVV	$1234, R1
	BEQ	R16, R1, 2(PC)
	MOVV	R0, 0(R0)

	// Initialize m->procid to Linux tid
	MOVV	$SYS_gettid, R2
	SYSCALL

	MOVV	-24(R29), R18		// fn
	MOVV	-16(R29), R17		// g
	MOVV	-8(R29), R16		// m

	BEQ	R16, nog
	BEQ	R17, nog

	MOVV	R2, m_procid(R16)

	# saved scheduler state. Find G's OS thread.
	m = ptr['m']
	if m == 0:
		return None, None
	for thr in gdb.selected_inferior().threads():
		if thr.ptid[1] == m['procid']:
			break
	else:
		return None, None
	# Get scheduler state from the G's OS thread state.
	curthr = gdb.selected_thread()
	try:
		thr.switch()
		pc = gdb.parse_and_eval('$pc')