XOR	 R0, R0 // reset R0

	// set g
	MOVD	m_g0(R3), g
	BL	runtime·save_g(SB)
	MOVD	R3, g_m(g)

	// Layout new m scheduler stack on os stack.
	MOVD	R1, R3
	MOVD	R3, (g_stack+stack_hi)(g)
	SUB	$(const_threadStackSize), R3		// stack size
	MOVD	R3, (g_stack+stack_lo)(g)
	ADD	$const_stackGuard, R3
	MOVD	R3, g_stackguard0(g)
	MOVD	R3, g_stackguard1(g)

	BL	runtime·mstart(SB)

	MOVD R0, R3

	get_tls(CX)
	MOVL	8(SP), DI
	MOVL	(g_stack+stack_hi)(DI), SI
	SUBL	4(SP), SI
	MOVL	DI, g(CX)
	MOVL	SI, SP

	MOVL	AX, ret+8(FP)
	RET
nosave:
	// Now on a scheduling stack (a pthread-created stack).
	SUBL	$32, SP
	ANDL	$~15, SP	// alignment, perhaps unnecessary
	MOVL	DX, 4(SP)	// save original stack pointer
	MOVL	BX, 0(SP)	// first argument in x86-32 ABI
	CALL	AX

	PUSH_REGS_HOST_TO_ABI0()

	// CX contains first arg newm
	MOVQ	m_g0(CX), DX		// g

	// Layout new m scheduler stack on os stack.
	MOVQ	SP, AX
	MOVQ	AX, (g_stack+stack_hi)(DX)
	SUBQ	$(64*1024), AX		// initial stack size (adjusted later)
	MOVQ	AX, (g_stack+stack_lo)(DX)
	ADDQ	$const_stackGuard, AX
	MOVQ	AX, g_stackguard0(DX)
	MOVQ	AX, g_stackguard1(DX)

	// Set up tls.
	LEAQ	m_tls(CX), DI

	MOVB	runtime·iscgo(SB),R12
	CMPBNE	R12, $0, nosaveg

	MOVD	m_gsignal(R6), R12	// g.m.gsignal
	CMPBEQ	R12, $0, nosaveg

	CMPBEQ	g, R12, nosaveg
	MOVD	(g_stack+stack_lo)(R12), R12 // g.m.gsignal.stack.lo
	MOVD	g, (R12)

	BL	R9 // to vdso lookup

	MOVD	$0, (R12)

	JMP	finish

nosaveg:
	BL	R9					// to vdso lookup

finish:
	MOVD	0(R15), R3		// sec
	MOVD	8(R15), R5		// nsec

A. Unique TensorFlower <******@****.***> 1690483910 -0700

Andy Ly <******@****.***> 1576078406 -0800

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
- 45557
releaseNotes:
- |

	EvGoSleep           event.Type = 19 // goroutine calls Sleep [timestamp, stack]
	EvGoBlock           event.Type = 20 // goroutine blocks [timestamp, stack]
	EvGoUnblock         event.Type = 21 // goroutine is unblocked [timestamp, goroutine id, seq, stack]
	EvGoBlockSend       event.Type = 22 // goroutine blocks on chan send [timestamp, stack]
	EvGoBlockRecv       event.Type = 23 // goroutine blocks on chan recv [timestamp, stack]

		ev, err := r.ReadByte()
		if err != nil {
			return err
		}
		if event.Type(ev) != go122.EvStack {
			return fmt.Errorf("expected stack event, got %d", ev)
		}

		// Read the stack's ID.
		id, err := binary.ReadUvarint(r)
		if err != nil {
			return err
		}

		// Read how many frames are in each stack.
		nFrames, err := binary.ReadUvarint(r)
		if err != nil {
			return err
		}

		return false
	}
	// pending is not absent, therefore it has either a stack mapping,
	// or registers, or both.
	if pending.onStack() && pending.StackOffset != new.StackOffset {
		// if pending has a stack offset, then new must also, and it
		// must be the same (StackOffset encodes onStack).
		return false
	}
	if pending.Registers&new.Registers != pending.Registers {