Method threadsRequest

src/gdb.ts:2303–2414

(response: DebugProtocol.ThreadsResponse)

    }

    protected threadsRequest(response: DebugProtocol.ThreadsResponse): Promise<void> {
        response.body = { threads: [] };
        if (!this.isMIStatusStopped() || !this.stopped || this.disableSendStoppedEvents || this.continuing) {
            this.sendResponse(response);
            return Promise.resolve();
        }

        if (this.sendDummyStackTrace) {
            if (this.args.showDevDebugOutput) {
                this.handleMsg('log', 'Returning dummy thread-id to workaround VSCode issue with pause button not working\n');
            }
            const useThread = this.currentThreadId || (this.activeThreadIds.size ? this.activeThreadIds.values[0] : 1);
            response.body.threads = [new Thread(useThread, 'cortex-debug-dummy-thread')];
            this.sendResponse(response);
            return Promise.resolve();
        }

        return new Promise<void>(async (resolve) => {
            try {
                const threadIdNode = await this.miDebugger.sendCommand('thread-list-ids');
                const threadIds: number[] = threadIdNode.result('thread-ids').map((ti) => parseInt(ti[1]));
                const currentThread = threadIdNode.result('current-thread-id');

                if (!threadIds || (threadIds.length === 0)) {
                    // Yes, this does happen at the very beginning of an RTOS session
                    this.sendResponse(response);
                    resolve();
                    return;
                }

                for (const thId of threadIds) {
                    // Make sure VSCode knows about all the threads. GDB may still be in the process of notifying
                    // new threads while we already have a thread-list. Technically, this should never happen
                    if (!this.activeThreadIds.has(thId)) {
                        this.handleThreadCreated({ threadId: thId, threadGroupId: 'i1' });
                    }
                }

                if (!currentThread) {
                    this.currentThreadId = threadIds.findIndex((x) => {
                        return x === this.stoppedThreadId;
                    }) >= 0 ? this.stoppedThreadId : threadIds[0];
                    if (traceThreads) {
                        this.handleMsg('log', `**** thread-list-ids: no current thread, setting to ${this.currentThreadId}\n`);
                    }
                    if (threadIds.length > 1) {    // No confusion when there is only one thread
                        // thread-select doesn't actually work on most embedded gdb-servers. But we will at least
                        // be in sync with gdb for querying local variables, etc. Things may rectify themselves like
                        // they do with OpenOCD bit later. In general, this only happens with buggy gdb-servers
                        await this.miDebugger.sendCommand(`thread-select ${this.currentThreadId}`);
                    }
                }
                else {
                    this.currentThreadId = parseInt(currentThread);
                    if (traceThreads) {
                        this.handleMsg('log', `**** thread-list-ids: current thread = ${this.currentThreadId}\n`);
                    }
                }