Method stackTraceRequest

src/gdb.ts:2416–2484

(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments)

    }

    protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments): Promise<void> {
        response.body = {
            stackFrames: [],
            totalFrames: 0
        };
        // Handle optional args when not passed
        args.startFrame = args.startFrame ?? 0;
        args.levels = args.levels ?? Infinity;
        if (!this.isMIStatusStopped() || !this.stopped || this.disableSendStoppedEvents || this.continuing) {
            this.sendResponse(response);
            return Promise.resolve();
        }
        if (this.sendDummyStackTrace) {
            // VSCode has a bug. Once we send a Stopped Event, VSCode pause button refuses to work until some stack trace is
            // returned. We have issues during startup (and reset/restart) where we need to continue right after the initial
            // stop. So, we wait until VSCode got some dummy stack trace to continue. Not an issue if you have runToEntryPoint
            // but is an issue otherwise.
            // This also prevents disassembly getting requested while we are still in the middle of starting up and the PC can
            // temporarily be in la la land.
            if (this.args.showDevDebugOutput) {
                this.handleMsg('log', `Returning dummy stack frame to workaround VSCode issue with pause button not working: ${JSON.stringify(args)}\n`);
            }
            response.body.stackFrames = [new StackFrame(encodeReference(args.threadId, 0), 'cortex-debug-dummy', null, 0, 0)];
            response.body.totalFrames = 1;
            this.onInternalEvents.emit('stack-trace-request');
            this.sendResponse(response);
            return Promise.resolve();
        }
        return new Promise<void>(async (resolve) => {
            try {
                const maxDepth = await this.miDebugger.getStackDepth(args.threadId);
                const highFrame = Math.min(maxDepth, args.startFrame + args.levels) - 1;
                const stack = await this.miDebugger.getStack(args.threadId, args.startFrame, highFrame);
                const ret: StackFrame[] = [];
                for (const element of stack) {
                    const stackId = encodeReference(args.threadId, element.level);
                    const file = element.file;
                    const src = file ? new Source(element.fileName, file) : undefined;
                    const sf = new StackFrame(stackId, element.function + '@' + element.address, src, element.line, 0);
                    sf.instructionPointerReference = element.address;
                    ret.push(sf);
                }

                if ((ret.length > 0) && !ret[0].source) {
                    /*
                    // Let VSCode stabilize on our stack information
                    setTimeout(() => {
                        this.sendEvent(new GenericCustomEvent('open-disassembly', {}));
                    }, 10);
                    */
                }

                response.body = {
                    stackFrames: ret,
                    totalFrames: maxDepth
                };
                this.sendResponse(response);
                resolve();