MOVD	m_g0(R21), R7
	MOVD	(g_sched+gobuf_sp)(R7), R1	// Set SP to g0 stack

noswitch:
	SUB	$16, R1                 // Space for results
	RLDICR	$0, R1, $59, R1         // Align for C code
	MOVD	R12, CTR
	MOVD	R1, R4

	// Store g on gsignal's stack, so if we receive a signal
	// during VDSO code we can find the g.
	// If we don't have a signal stack, we won't receive signal,
	// so don't bother saving g.

	return nil
}

// validateStackStrings makes sure all the string references in
// the stack table are present in the string table.
func validateStackStrings(
	stacks *dataTable[stackID, stack],
	strings *dataTable[stringID, string],
	frames map[uint64]frame,
) error {
	var err error
	stacks.forEach(func(id stackID, stk stack) bool {
		for _, pc := range stk.pcs {
			frame, ok := frames[pc]
			if !ok {

	}
	ev := event.Type(evb)
	spec := r.specs[ev]
	args, err := r.readArgs(len(spec.Args))
	if err != nil {
		return Event{}, err
	}
	if spec.IsStack {
		len := int(args[1])
		for i := 0; i < len; i++ {
			// Each stack frame has four args: pc, func ID, file ID, line number.
			frame, err := r.readArgs(4)
			if err != nil {
				return Event{}, err
			}
			args = append(args, frame...)
		}
	}

		// 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;
    }

UserTaskEnd dt=24 task=10 stack=62
UserLog dt=18 task=4 key_string=24 value_string=63 stack=63
UserTaskBegin dt=11 task=12 parent_task=4 name_string=26 stack=64
UserLog dt=21 task=12 key_string=27 value_string=64 stack=65
UserRegionBegin dt=7 task=12 name_string=29 stack=66
GoCreate dt=33 new_g=5 new_stack=17 stack=67
GoCreate dt=12 new_g=6 new_stack=17 stack=67
GoCreate dt=9 new_g=7 new_stack=17 stack=67
GoCreate dt=8 new_g=8 new_stack=17 stack=67

			}

			if len(stack) > 0 {
				stack += " "
			}
			stack += FmtSprintf("%s:%d", name, line-tiuStart)
		}

		if stack != prevStack {
			prevStack = stack

			t.Logf("tiuTest+%#x: %s", pc-pc1, stack)

			if _, ok := want[stack]; ok {
				want[stack]++
			}
		}
	}

	// Check that we got all the stacks we wanted.
	for stack, count := range want {
		if count == 0 {

GoUnblock dt=12 g=53 g_seq=3 stack=0
GoStart dt=5 g=53 g_seq=4
GoLabel dt=1 label_string=2
GoBlock dt=1751 reason_string=15 stack=5
GoUnblock dt=12 g=53 g_seq=5 stack=0
GoStart dt=6 g=53 g_seq=6
GoLabel dt=3 label_string=2
GoBlock dt=119 reason_string=15 stack=5
GoStart dt=15 g=88 g_seq=4
GoBlock dt=50 reason_string=13 stack=11
GoUnblock dt=1212 g=54 g_seq=15 stack=0
GoStart dt=6 g=54 g_seq=16

        !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()

func (gs *gState[R]) setStartCause(ts trace.Time, name string, resource uint64, stack trace.Stack) {
	gs.startCause.time = ts
	gs.startCause.name = name
	gs.startCause.resource = resource
	gs.startCause.stack = stack
}

// created indicates that this goroutine was just created by the provided creator.
func (gs *gState[R]) created(ts trace.Time, creator R, stack trace.Stack) {
	if creator == R(noResource) {
		return
	}