Method walkVM

src/stackWalker.cpp:206–503

}

int StackWalker::walkVM(void* ucontext, ASGCT_CallFrame* frames, int max_depth, int lock_index,
                        StackWalkFeatures features, EventType event_type) {
    const void* pc;
    uintptr_t fp;
    uintptr_t sp;
    uintptr_t bottom = (uintptr_t)&sp + MAX_WALK_SIZE;

    StackFrame frame(ucontext ? ucontext : &empty_ucontext);
    if (ucontext == NULL) {
        pc = callerPC();
        fp = (uintptr_t)callerFP();
        sp = (uintptr_t)callerSP();
    } else {
        pc = (const void*)frame.pc();
        fp = frame.fp();
        sp = frame.sp();
    }

    Profiler* profiler = Profiler::instance();
    int bcp_offset = InterpreterFrame::bcp_offset();

    jmp_buf current_ctx;
    crash_protection_ctx[lock_index] = &current_ctx;

    // Should be preserved across setjmp/longjmp
    volatile int depth = 0;

    if (setjmp(current_ctx) != 0) {
        crash_protection_ctx[lock_index] = NULL;
        if (depth < max_depth) {
            fillFrame(frames[depth++], BCI_ERROR, "break_not_walkable");
        }
        return depth;
    }

    // Show extended frame types and stub frames for execution-type events
    bool details = event_type <= MALLOC_SAMPLE || features.mixed;

    JavaFrameAnchor* anchor = NULL;
    VMThread* vm_thread = VMThread::current();
    if (vm_thread != NULL && vm_thread->isJavaThread()) {
        // For simple stack traces (e.g. for allocation profiling)
        // jump directly to the first Java frame
        if (details) {
            anchor = vm_thread->anchor();
        } else if (!vm_thread->anchor()->restoreFrame(pc, sp, fp)) {
            return 0;
        }
    }

    unwind_loop:
    uintptr_t prev_sp = sp;
    while (depth < max_depth) {
        // As an extra safety measure, verify stack pointer invariants on every iteration
        if (sp < prev_sp || sp >= bottom || !aligned(sp)) {
            fillFrame(frames[depth++], BCI_ERROR, "break_stack_range");
            break;
        }