Merge branch 'topic/gdb_target' into 'master'

AnthonyLeonardoGracio · AnthonyLeonardoGracio · commit dfaa7e2260c0 · 2025-01-29T13:35:06.000Z
Prepend target to GDB for non-native projects

See merge request eng/ide/ada_language_server!1902
diff --git a/integration/vscode/ada/src/ExtensionState.ts b/integration/vscode/ada/src/ExtensionState.ts
@@ -9,10 +9,12 @@ import { AdaCodeLensProvider } from './AdaCodeLensProvider';
 import { createClient } from './clients';
 import { AdaInitialDebugConfigProvider, initializeDebugging } from './debugConfigProvider';
 import { logger } from './extension';
+import { existsSync } from 'fs';
+import path from 'path';
 import { GnatTaskProvider } from './gnatTaskProvider';
 import { initializeTesting } from './gnattest';
 import { GprTaskProvider } from './gprTaskProvider';
-import { getArgValue, TERMINAL_ENV_SETTING_NAME } from './helpers';
+import { getArgValue, TERMINAL_ENV_SETTING_NAME, exe, getEvaluatedTerminalEnv } from './helpers';
 import {
     SimpleTaskDef,
     SimpleTaskProvider,
@@ -54,19 +56,23 @@ export class ExtensionState {
      */
     cachedProjectUri: vscode.Uri | undefined;
     cachedObjectDir: string | undefined;
+    cachedTargetPrefix: string | undefined;
     cachedMains: string[] | undefined;
     cachedExecutables: string[] | undefined;
     cachedAlireTomls: vscode.Uri[] | undefined;
+    cachedGdb: string | undefined | null = undefined;
 
     private adaTaskProvider?: SimpleTaskProvider;
     private sparkTaskProvider?: SimpleTaskProvider;
 
     private clearALSCache() {
         this.cachedProjectUri = undefined;
         this.cachedObjectDir = undefined;
+        this.cachedTargetPrefix = undefined;
         this.cachedMains = undefined;
         this.cachedExecutables = undefined;
         this.cachedAlireTomls = undefined;
+        this.cachedGdb = undefined;
     }
 
     constructor(context: vscode.ExtensionContext) {
@@ -237,6 +243,58 @@ export class ExtensionState {
         return attrValue;
     }
 
+    /**
+     *
+     * @returns the full path to the `gdb` executable, taking into consideration the
+     * `PATH` variable in the `terminal.integrated.env.*` setting if set. Otherwise,
+     * the `PATH` variable of the current process environment is considered. When
+     * a non-native target is specified, it will be prepeneded to the `gdb` executable
+     * before looking in the `PATH` (e.g: `arm-eabi-gdb` for `arm-eabi` target).
+     *
+     * The current process environment is unlikely to change during the lifetime of
+     * the extension, and we already prompt the User to reload the window in case
+     * the `terminal.integrated.env.*` variables change. For this reason, we compute
+     * the value only on the first call, and cache it for subsequent calls to return
+     * it efficiently.
+     *
+     * @param target - The target for which gdb should be looked for.
+     */
+    public getOrFindGdb(target: string = ''): string | undefined {
+        if (this.cachedGdb === undefined) {
+            /**
+             * If undefined yet, try to compute it.
+             */
+            const env = getEvaluatedTerminalEnv();
+            let pathVal: string;
+            if (env && 'PATH' in env) {
+                pathVal = env.PATH ?? '';
+            } else if ('PATH' in process.env) {
+                pathVal = process.env.PATH ?? '';
+            } else {
+                pathVal = '';
+            }
+
+            const gdbExeBasename = target != '' ? `${target}-gdb${exe}` : `gdb${exe}`;
+            const gdb = pathVal
+                .split(path.delimiter)
+                .map<string>((v) => path.join(v, gdbExeBasename))
+                .find(existsSync);
+
+            if (gdb) {
+                // Found
+                this.cachedGdb = gdb;
+                return this.cachedGdb;
+            } else {
+                // Not found. Assign null to cache to avoid recomputing at every call.
+                this.cachedGdb = null;
+            }
+        }
+
+        // When returning, coerce null to undefined because the distinction doesn't
+        // matter on the caller side.
+        return this.cachedGdb ?? undefined;
+    }
+
     /**
      * @returns the URI of the main project file from the ALS
      */
@@ -253,6 +311,31 @@ export class ExtensionState {
         return this.cachedProjectUri;
     }
 
+    /**
+     * Returns the target prefix that should be used when spawning tools
+     * like gnat, gcc or gdb.
+     * For instance if the project has an 'arm-eabi' target, this
+     * function will return 'arm-eabi'. For native projects, this
+     * will return an empty string.
+     *
+     * @returns the target prefix
+     */
+    public async getTargetPrefix(): Promise<string> {
+        if (!this.cachedTargetPrefix) {
+            // Get the compiler driver's path from the Compiler.Driver project
+            // attribute, and delete the last bit to get the prefix
+            const driverPath = (await this.getProjectAttributeValue(
+                'driver',
+                'compiler',
+                'ada',
+            )) as string;
+            const driver = path.basename(driverPath);
+            this.cachedTargetPrefix = driver.substring(0, driver.lastIndexOf('-'));
+        }
+
+        return this.cachedTargetPrefix;
+    }
+
     /**
      * @returns the full path of the main project file from the ALS
      */
diff --git a/integration/vscode/ada/src/commands.ts b/integration/vscode/ada/src/commands.ts
@@ -593,6 +593,7 @@ async function buildAndDebugSpecifiedMain(main: vscode.Uri): Promise<void> {
 
     const wsFolder = vscode.workspace.getWorkspaceFolder(main);
     const adaMain = await findAdaMain(main.fsPath);
+    const target = await adaExtState.getTargetPrefix();
     if (adaMain) {
         /**
          * The vscode API doesn't provide a way to list both automatically
@@ -602,7 +603,7 @@ async function buildAndDebugSpecifiedMain(main: vscode.Uri): Promise<void> {
          * the given main URI.
          */
         // Create a launch config for this main to help with matching
-        const configToMatch = initializeConfig(adaMain);
+        const configToMatch = initializeConfig(adaMain, target);
         logger.debug('Debug config to match:\n' + JSON.stringify(configToMatch, null, 2));
 
         let matchingConfig = undefined;
diff --git a/integration/vscode/ada/src/debugConfigProvider.ts b/integration/vscode/ada/src/debugConfigProvider.ts
@@ -1,16 +1,7 @@
 import assert from 'assert';
-import { existsSync } from 'fs';
-import path from 'path';
 import * as vscode from 'vscode';
 import { adaExtState } from './extension';
-import {
-    AdaMain,
-    exe,
-    getAdaMains,
-    getEvaluatedTerminalEnv,
-    getProjectFile,
-    getProjectFileRelPath,
-} from './helpers';
+import { AdaMain, getAdaMains, getProjectFile, getProjectFileRelPath } from './helpers';
 import { BUILD_PROJECT_TASK_NAME, getBuildTaskName } from './taskProviders';
 
 export const ADA_DEBUG_BACKEND_TYPE = 'cppdbg';
@@ -40,8 +31,9 @@ export const adaDynamicDebugConfigProvider = {
         _folder?: vscode.WorkspaceFolder,
     ): Promise<AdaConfig[]> {
         const mains = await getAdaMains();
+        const target = await adaExtState.getTargetPrefix();
         const configs: AdaConfig[] = mains.flatMap((m) => {
-            return [initializeConfig(m), createAttachConfig(m)];
+            return [initializeConfig(m, target), createAttachConfig(m, target)];
         });
         if (configs.length == 0) {
             /**
@@ -112,55 +104,6 @@ export function initializeDebugging(ctx: vscode.ExtensionContext): {
     return { providerInitial: providerInitial, providerDynamic: adaDynamicDebugConfigProvider };
 }
 
-let cachedGdb: string | undefined | null = undefined;
-
-/**
- *
- * @returns the full path to the `gdb` executable, taking into consideration the
- * `PATH` variable in the `terminal.integrated.env.*` setting if set. Otherwise,
- * the `PATH` variable of the current process environment is considered.
- *
- * The current process environment is unlikely to change during the lifetime of
- * the extension, and we already prompt the User to reload the window in case
- * the `terminal.integrated.env.*` variables change. For this reason, we compute
- * the value only on the first call, and cache it for subsequent calls to return
- * it efficiently.
- */
-export function getOrFindGdb(): string | undefined {
-    if (cachedGdb == undefined) {
-        /**
-         * If undefined yet, try to compute it.
-         */
-        const env = getEvaluatedTerminalEnv();
-        let pathVal: string;
-        if (env && 'PATH' in env) {
-            pathVal = env.PATH ?? '';
-        } else if ('PATH' in process.env) {
-            pathVal = process.env.PATH ?? '';
-        } else {
-            pathVal = '';
-        }
-
-        const gdb = pathVal
-            .split(path.delimiter)
-            .map<string>((v) => path.join(v, 'gdb' + exe))
-            .find(existsSync);
-
-        if (gdb) {
-            // Found
-            cachedGdb = gdb;
-            return cachedGdb;
-        } else {
-            // Not found. Assign null to cache to avoid recomputing at every call.
-            cachedGdb = null;
-        }
-    }
-
-    // When returning, coerce null to undefined because the distinction doesn't
-    // matter on the caller side.
-    return cachedGdb ?? undefined;
-}
-
 /**
  * Initialize a debug configuration based on 'cppdbg' for the given executable
  * if specified. Otherwise the program field includes
@@ -175,7 +118,7 @@ export function getOrFindGdb(): string | undefined {
  * 'program' parameter.
  * @returns an AdaConfig
  */
-export function initializeConfig(main: AdaMain, name?: string): AdaConfig {
+export function initializeConfig(main: AdaMain, target: string, name?: string): AdaConfig {
     // TODO it would be nice if this and the package.json configuration snippet
     // were the same.
     const config: AdaConfig = {
@@ -192,7 +135,7 @@ export function initializeConfig(main: AdaMain, name?: string): AdaConfig {
         MIMode: 'gdb',
         preLaunchTask: main ? getBuildTaskName(main) : BUILD_PROJECT_TASK_NAME,
         setupCommands: setupCmd,
-        miDebuggerPath: getOrFindGdb(),
+        miDebuggerPath: adaExtState.getOrFindGdb(target),
     };
 
     return config;
@@ -283,9 +226,9 @@ export class AdaInitialDebugConfigProvider implements vscode.DebugConfigurationP
             return debugConfiguration;
         } else {
             const main = await getOrAskForProgram();
-
+            const target = await adaExtState.getTargetPrefix();
             if (main) {
-                return initializeConfig(main);
+                return initializeConfig(main, target);
             }
         }
 
@@ -449,7 +392,7 @@ async function getAdaMainForSourceFile(
     return mains.find((val) => srcPath == val.mainFullPath);
 }
 
-function createAttachConfig(adaMain: AdaMain): AdaConfig {
+function createAttachConfig(adaMain: AdaMain, target: string): AdaConfig {
     return {
         name: `Ada: Attach debugger to running process - ${adaMain.mainRelPath()}`,
         type: ADA_DEBUG_BACKEND_TYPE,
@@ -463,7 +406,7 @@ function createAttachConfig(adaMain: AdaMain): AdaConfig {
          * to trigger an unwanted rebuild, so we don't set a preLaunchTask.
          */
         // preLaunchTask: adaMain ? getBuildTaskName(adaMain) : BUILD_PROJECT_TASK_NAME,
-        miDebuggerPath: getOrFindGdb(),
+        miDebuggerPath: adaExtState.getOrFindGdb(target),
         setupCommands: setupCmd,
     };
 }
diff --git a/integration/vscode/ada/test/general/debug.test.ts b/integration/vscode/ada/test/general/debug.test.ts
@@ -3,7 +3,6 @@ import {
     AdaConfig,
     adaDynamicDebugConfigProvider,
     createQuickPicksInitialLaunch,
-    getOrFindGdb,
 } from '../../src/debugConfigProvider';
 import { exe } from '../../src/helpers';
 import { activate } from '../utils';
@@ -38,7 +37,7 @@ suite('Dbg Cfgs', function () {
                         text: 'set multiple-symbols cancel',
                     },
                 ],
-                miDebuggerPath: getOrFindGdb() ?? '<undefined>',
+                miDebuggerPath: adaExtState.getOrFindGdb() ?? '<undefined>',
             },
             {
                 name: 'Ada: Attach debugger to running process - src/main1.adb',
@@ -59,7 +58,7 @@ suite('Dbg Cfgs', function () {
                         text: 'set multiple-symbols cancel',
                     },
                 ],
-                miDebuggerPath: getOrFindGdb() ?? '<undefined>',
+                miDebuggerPath: adaExtState.getOrFindGdb() ?? '<undefined>',
             },
             {
                 type: 'cppdbg',
@@ -84,7 +83,7 @@ suite('Dbg Cfgs', function () {
                         text: 'set multiple-symbols cancel',
                     },
                 ],
-                miDebuggerPath: getOrFindGdb() ?? '<undefined>',
+                miDebuggerPath: adaExtState.getOrFindGdb() ?? '<undefined>',
             },
             {
                 name: 'Ada: Attach debugger to running process - src/test.adb',
@@ -105,7 +104,7 @@ suite('Dbg Cfgs', function () {
                         text: 'set multiple-symbols cancel',
                     },
                 ],
-                miDebuggerPath: getOrFindGdb() ?? '<undefined>',
+                miDebuggerPath: adaExtState.getOrFindGdb() ?? '<undefined>',
             },
         ];
     });
