Fix erroneous assumption of async mode when target does not support it (#440)

* Fix erroneous assumption of async mode when target does not support it

When async mode is requested using `-gdb-set mi-async on`, check with
GDB whether the request was actually granted once connected to a target.
It may not be, depending on the capabilities of the target (in
particular, the "native" target on Windows does not support async mode
in GDB < 13), and in such a case, later decisions based on
`gdb.getAsyncMode()` would be wrong.

Signed-off-by: Christian Walther <[email protected]>

* Move check for async mode after initCommands

Signed-off-by: Christian Walther <[email protected]>

---------

Signed-off-by: Christian Walther <[email protected]>

Author: cwalther

src/desktop/GDBTargetDebugSession.ts

@@ -620,6 +620,14 @@ export class GDBTargetDebugSession extends GDBDebugSession {
                 args.initCommands
             );
 
+            // Check for async mode support after initCommands have possibly
+            // selected a different target
+            if (this.gdb.getAsyncMode()) {
+                if (await this.gdb.confirmAsyncMode()) {
+                    this.warnAsyncDisabled();
+                }
+            }
+
             // Initialize UART
             if (target.uart !== undefined) {
                 this.initializeUARTConnection(target.uart, target.host);

src/gdb/GDBBackend.ts

@@ -17,6 +17,7 @@ import {
 import {
     MIBreakpointInsertOptions,
     MIBreakpointLocation,
+    MIFeaturesResponse,
     MIShowResponse,
     sendDataEvaluateExpression,
     sendExecInterrupt,
@@ -39,6 +40,7 @@ export class GDBBackend extends events.EventEmitter implements IGDBBackend {
     private gdbVersion?: string;
     protected gdbAsync = false;
     protected gdbNonStop = false;
+    protected asyncRequestedExplicitly = false;
     protected hardwareBreakpoint = false;
 
     constructor(protected readonly processManager: IGDBProcessManager) {
@@ -80,6 +82,9 @@ export class GDBBackend extends events.EventEmitter implements IGDBBackend {
                 this.emit('consoleStreamOutput', newChunk, 'stderr');
             });
         }
+        this.asyncRequestedExplicitly = !!(
+            requestArgs.gdbAsync || requestArgs.gdbNonStop
+        );
         await this.setNonStopMode(requestArgs.gdbNonStop);
         await this.setAsyncMode(requestArgs.gdbAsync);
     }
@@ -112,6 +117,29 @@ export class GDBBackend extends events.EventEmitter implements IGDBBackend {
         return this.gdbAsync;
     }
 
+    // When you setAsyncMode(true), call this after selecting a target (either
+    // explicitly using -target-select, or using -target-attach or -exec-run
+    // which implicitly select the "native" target (see docs of `set
+    // auto-connect-native-target`)) to check if the target actually supports
+    // async mode. If not, it resets getAsyncMode() to false.
+    // In particular, the "native" target on Windows does not support async mode
+    // in GDB < 13.
+    // Returns true iff async mode was explicitly requested in the launch/attach
+    // arguments but is unsupported by the target.
+    public async confirmAsyncMode() {
+        const features = (
+            (await this.sendCommand(
+                '-list-target-features'
+            )) as MIFeaturesResponse
+        ).features;
+        const actualAsync =
+            Array.isArray(features) && features.includes('async');
+        const warningNeeded =
+            this.gdbAsync && !actualAsync && this.asyncRequestedExplicitly;
+        this.gdbAsync = actualAsync;
+        return warningNeeded;
+    }
+
     public async setNonStopMode(isSet?: boolean) {
         if (isSet === undefined) {
             isSet = false;

src/gdb/GDBDebugSessionBase.ts

@@ -352,6 +352,15 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
         );
     }
 
+    protected warnAsyncDisabled() {
+        this.sendEvent(
+            new OutputEvent(
+                'The target does not support gdbAsync. Most debugger interactions will only work while the target is stopped.',
+                'important'
+            )
+        );
+    }
+
     protected async attachOrLaunchRequest(
         response: DebugProtocol.Response,
         request: 'launch' | 'attach',
@@ -384,10 +393,30 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
             this.sendEvent(
                 new OutputEvent(`attached to process ${attachArgs.processId}`)
             );
+        } else {
+            if (this.gdb.getAsyncMode()) {
+                // Checking whether the target supports async mode needs a
+                // target connection. Launching will implicitly select the
+                // "native" target (see docs of `set
+                // auto-connect-native-target`), so we may just as well do it
+                // explicitly here.
+                await mi.sendTargetSelectRequest(this.gdb, {
+                    type: 'native',
+                    parameters: [],
+                });
+            }
         }
 
         await this.gdb.sendCommands(args.initCommands);
 
+        // Check for async mode support after initCommands have possibly
+        // selected a different target
+        if (this.gdb.getAsyncMode()) {
+            if (await this.gdb.confirmAsyncMode()) {
+                this.warnAsyncDisabled();
+            }
+        }
+
         if (request === 'launch') {
             const launchArgs = args as LaunchRequestArguments;
             if (launchArgs.arguments) {

src/mi/base.ts

@@ -17,6 +17,11 @@ export interface MIShowResponse extends MIResponse {
     value?: string;
 }
 
+/** Response to -list-features and -list-target-features */
+export interface MIFeaturesResponse extends MIResponse {
+    features?: string[];
+}
+
 export abstract class MIRequest<R> {
     public abstract send(backend: IGDBBackend): Promise<R>;
 }

src/types/gdb.ts

@@ -86,6 +86,8 @@ export interface IGDBBackend extends EventEmitter {
 
     getAsyncMode: () => boolean;
 
+    confirmAsyncMode: () => Promise<boolean>;
+
     setNonStopMode: (isSet?: boolean) => Promise<void>;
 
     isNonStopMode: () => boolean;

src/web/GDBTargetDebugSession.ts

@@ -469,6 +469,14 @@ export class GDBTargetDebugSession extends GDBDebugSession {
                 args.initCommands
             );
 
+            // Check for async mode support after initCommands have possibly
+            // selected a different target
+            if (this.gdb.getAsyncMode()) {
+                if (await this.gdb.confirmAsyncMode()) {
+                    this.warnAsyncDisabled();
+                }
+            }
+
             // Load additional code/symbols
             if (args.imageAndSymbols) {
                 if (args.imageAndSymbols.imageFileName) {