MOVD	RSP, R13
	SUB	$16, R13
	MOVD	R13, RSP
	MOVD	R4, 0(RSP)	// save old g on stack
	MOVD	(g_stack+stack_hi)(R4), R4
	SUB	R2, R4
	MOVD	R4, 8(RSP)	// save depth in old g stack (can't just save SP, as stack might be copied during a callback)
	BL	(R1)
	MOVD	R0, R9

	// Restore g, stack pointer. R0 is errno, so don't touch it
	MOVD	0(RSP), g
	BL	runtime·save_g(SB)
	MOVD	(g_stack+stack_hi)(g), R5

	if err != nil {
		return Event{}, fmt.Errorf("reading args for %s: %v", evStr, err)
	}
	if spec.IsStack {
		len := int(args[1])
		for i := 0; i < len; i++ {
			line, err := r.nextLine()
			if err == io.EOF {
				return Event{}, fmt.Errorf("unexpected EOF while reading stack: args=%v", args)
			}
			if err != nil {
				return Event{}, err
			}
			frame, err := readArgs(line, frameFields)

	ANDI	$~7, X2 // Align for C code
	MOV	$8(X2), A1

	// Store g on gsignal's stack, see sys_linux_arm64.s for detail
	MOVBU	runtime·iscgo(SB), S4
	BNEZ	S4, nosaveg
	MOV	m_gsignal(S3), S4 // g.m.gsignal
	BEQZ	S4, nosaveg
	BEQ	g, S4, nosaveg
	MOV	(g_stack+stack_lo)(S4), S4 // g.m.gsignal.stack.lo
	MOV	g, (S4)

	JALR	RA, A7

	MOV	ZERO, (S4)
	JMP	finish

nosaveg:
	JALR	RA, A7

	b0 := g1.Batch(trace.ThreadID(0), 0)
	b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
	b0.Event("GoCreate", trace.GoID(5), testgen.NoStack, testgen.NoStack)
	b0.Event("GoStart", trace.GoID(5), testgen.Seq(1))
	b0.Event("GoStop", "whatever", testgen.NoStack)

	BEQ	R25, nosaveg
	BEQ	g, R25, nosaveg

	MOVV	(g_stack+stack_lo)(R25), R25	// g.m.gsignal.stack.lo
	MOVV	g, (R25)

	JAL	(R20)

	MOVV	R0, (R25)
	JMP	finish

nosaveg:
	JAL	(R20)

finish:
	MOVV	0(R3), R7	// sec
	MOVV	8(R3), R5	// nsec

	MOVV	R23, R3	// restore SP
	// Restore vdsoPC, vdsoSP
	// We don't worry about being signaled between the two stores.

		// on another stack. That could confuse callers quite a bit.
		// Instead, we require that initAt and any other function that
		// accepts an sp for the current goroutine (typically obtained by
		// calling getcallersp) must not run on that goroutine's stack but
		// instead on the g0 stack.
		throw("cannot trace user goroutine on its own stack")
	}

        CacheOperationStack stack = stackForThread.get();
        return stack != null && stack.isInCacheAction();
    }

    private CacheOperationStack getOrCreateStack() {
        CacheOperationStack stack = stackForThread.get();
        if (stack == null) {
            stack = new CacheOperationStack();
            stackForThread.set(stack);
        }
        return stack;
    }

        !stream2.forCurrentCaller().stack.empty
        !stream2.forCurrentCaller().stack.empty
        stream2.forCurrentCaller().stack.empty

        stream1.forCurrentCaller().stack.empty
    }

    def "keeps stack trace after limit has been reached when diagnostics constructed from exception"() {
        given:
        def stream = factory.newStream()
        stream.forCurrentCaller()

				inlined := (j != len(loc.Line)-1)
				stack.Sources = append(stack.Sources, getSrc(line, inlined))
			}
		}

		leaf := stack.Sources[len(stack.Sources)-1]
		s.Sources[leaf].Self += value
		s.Stacks = append(s.Stacks, stack)
	}
}

func (s *StackSet) fillPlaces() {
	for i, stack := range s.Stacks {
		seenSrcs := map[int]bool{}
		for j, src := range stack.Sources {
			if seenSrcs[src] {
				continue

	stacks map[trace.Stack]*traceviewer.ProfileRecord

	// pcs is the source-of-truth for deduplication. It is a map of
	// the actual PCs in the stack to a trace.Stack.
	pcs map[[pprofMaxStack]uint64]trace.Stack
}

func newStackMap() *stackMap {
	return &stackMap{
		stacks: make(map[trace.Stack]*traceviewer.ProfileRecord),
		pcs:    make(map[[pprofMaxStack]uint64]trace.Stack),
	}
}