Filter GDB warnings about not finding PC value in symtab entry (#688)

jreineckearm · web-flow · commit bc82c4ad4b50 · 2025-12-10T17:38:07.000+01:00
* Adds OutputEventFilter class
* Add output event filter instance to GDBTargetDebugSession. Per session to be consistent with other handlers and to allow
different filter flavours in future if needed.
* OutputEventFilter tests

---------

Signed-off-by: Jens Reinecke &lt;jens.reinecke@arm.com&gt;
diff --git a/src/debug-session/gdbtarget-debug-session.test.ts b/src/debug-session/gdbtarget-debug-session.test.ts
@@ -18,6 +18,7 @@ import * as vscode from 'vscode';
 import { debugSessionFactory } from '../__test__/vscode.factory';
 import { GDBTargetDebugSession } from './gdbtarget-debug-session';
 import { logger } from '../logger';
+import { DebugProtocol } from '@vscode/debugprotocol';
 
 const TEST_CBUILD_RUN_FILE = 'test-data/multi-core.cbuild-run.yml'; // Relative to repo root
 
@@ -109,4 +110,58 @@ describe('GDBTargetDebugSession', () => {
         const result = await gdbTargetSession.readMemoryU32(0xABABABAB);
         expect(result).toEqual(0x78563412);
     });
+
+    it('filters output events correctly', () => {
+        const makeEvent = (output: string, category: string): DebugProtocol.OutputEvent => ({
+            seq: 1,
+            type: 'event',
+            event: 'output',
+            body: {
+                output,
+                category
+            }
+        });
+        const makeEvents = (): DebugProtocol.OutputEvent[]  => [
+            makeEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', 'log'),
+            makeEvent('warning: (Error: pc 0x12345678 in address map, but not in symtab.)\n', 'log')
+        ];
+        const eventsToFilter = makeEvents();
+        const referenceEvents = makeEvents();
+        // Update to expected event names
+        referenceEvents.forEach(event => event.event = 'cmsis-debugger-discarded');
+        // Look out for logger output
+        const logDebugSpy = jest.spyOn(logger, 'debug');
+        // Call the filter
+        eventsToFilter.forEach(event => gdbTargetSession.filterOutputEvent(event));
+        // Check if logger was called (2 lines = event info + output)
+        expect(logDebugSpy).toHaveBeenCalledTimes(eventsToFilter.length*2);
+        // Compare the outputs
+        expect(eventsToFilter).toEqual(referenceEvents);
+    });
+
+    it('does not filter output events if they do not match criteria', () => {
+        const makeEvent = (output: string, category: string): DebugProtocol.OutputEvent => ({
+            seq: 1,
+            type: 'event',
+            event: 'output',
+            body: {
+                output,
+                category
+            }
+        });
+        const makeEvents = (): DebugProtocol.OutputEvent[]  => [
+            makeEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', 'foo'),
+            makeEvent('Error: pc 0x12345678 in address map, but not in symtab.', 'log')
+        ];
+        const eventsToFilter = makeEvents();
+        const referenceEvents = makeEvents();
+        // Look out for logger output
+        const logDebugSpy = jest.spyOn(logger, 'debug');
+        // Call the filter
+        eventsToFilter.forEach(event => gdbTargetSession.filterOutputEvent(event));
+        // Check if logger was called (should not be called if not filtered)
+        expect(logDebugSpy).not.toHaveBeenCalled();
+        // Compare the outputs, should be exact matches as inputs should not cause a match
+        expect(eventsToFilter).toEqual(referenceEvents);
+    });
 });
diff --git a/src/debug-session/gdbtarget-debug-session.ts b/src/debug-session/gdbtarget-debug-session.ts
@@ -19,6 +19,7 @@ import { DebugProtocol } from '@vscode/debugprotocol';
 import { logger } from '../logger';
 import { CbuildRunReader } from '../cbuild-run';
 import { PeriodicRefreshTimer } from './periodic-refresh-timer';
+import { OutputEventFilter } from './output-event-filter';
 
 /**
  * GDBTargetDebugSession - Wrapper class to provide session state/details
@@ -28,13 +29,32 @@ export class GDBTargetDebugSession {
     public readonly canAccessWhileRunning: boolean;
     private _cbuildRun: CbuildRunReader|undefined;
     private _cbuildRunParsePromise: Promise<void>|undefined;
+    private outputEventFilter = new OutputEventFilter();
 
     constructor(public session: vscode.DebugSession) {
         this.refreshTimer = new PeriodicRefreshTimer(this);
         this.canAccessWhileRunning = this.session.configuration.type === 'gdbtarget' && this.session.configuration['auxiliaryGdb'] === true;
         this.refreshTimer.enabled = this.canAccessWhileRunning;
     }
 
+    /**
+     * Filters and renames specific output events, logs those events to 'Arm CMSIS Debugger' output channel.
+     *
+     * Renaming the events to 'cmsis-debugger-discarded' makes VS Code and loaded debug view
+     * extensions ignore them.
+     *
+     * @param event The output event to process in the filter.
+     */
+    public filterOutputEvent(event: DebugProtocol.OutputEvent): void {
+        if (this.outputEventFilter.filterOutputEvent(event)) {
+            // Log original event properties for potential diagnostics purposes.
+            logger.debug(`[Filtered output event]: category='${event.body.category}', seq='${event.seq}', session='${this.session.name}'`);
+            logger.debug(`\t'${event.body.output}'`);
+            event.event = 'cmsis-debugger-discarded'; // Discard the event by changing the event name
+            return;
+        }
+    }
+
     public async getCbuildRun(): Promise<CbuildRunReader|undefined> {
         if (!this._cbuildRun) {
             return;
diff --git a/src/debug-session/gdbtarget-debug-tracker.test.ts b/src/debug-session/gdbtarget-debug-tracker.test.ts
@@ -245,6 +245,24 @@ describe('GDBTargetDebugTracker', () => {
             expect(result!.event).toEqual(stoppedEvent);
         });
 
+        it('calls a session output event filter', async () => {
+            const tracker = await adapterFactory!.createDebugAdapterTracker(debugSessionFactory(debugConfigurationFactory()));
+            // Create GDB target session object
+            tracker!.onWillStartSession!();
+            const ouptutEvent: DebugProtocol.OutputEvent = {
+                event: 'output',
+                type: 'event',
+                seq: 1,
+                body: {
+                    category: 'log',
+                    output: 'warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n'
+                }
+            };
+            tracker!.onDidSendMessage!(ouptutEvent);
+            // Expect event name was changed by filter
+            expect(ouptutEvent.event).toEqual('cmsis-debugger-discarded');
+        });
+
     });
 
     describe('refresh timer management', () => {
diff --git a/src/debug-session/gdbtarget-debug-tracker.ts b/src/debug-session/gdbtarget-debug-tracker.ts
@@ -130,6 +130,9 @@ export class GDBTargetDebugTracker {
             case 'exited':
                 gdbTargetSession?.refreshTimer.stop();
                 break;
+            case 'output':
+                gdbTargetSession?.filterOutputEvent(event as DebugProtocol.OutputEvent);
+                break;
         }
     }
 
diff --git a/src/debug-session/output-event-filter.test.ts b/src/debug-session/output-event-filter.test.ts
@@ -0,0 +1,70 @@
+/**
+ * Copyright 2025 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { DebugProtocol } from '@vscode/debugprotocol';
+import { OutputEventFilter } from './output-event-filter';
+
+const makeOutputEvent = (output: string, category: string|undefined): DebugProtocol.OutputEvent => {
+    const event = {
+        seq: 1,
+        type: 'event',
+        event: 'output',
+        body: {
+            output
+        }
+    };
+    if (category) {
+        Object.assign(event.body, { category });
+    }
+    return event;
+};
+
+describe('OutputEventFilter', () => {
+    let eventFilter: OutputEventFilter;
+
+    beforeEach(() => {
+        eventFilter = new OutputEventFilter();
+    });
+
+    it('filters events correctly', () => {
+        const events = [
+            makeOutputEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', 'log'),
+            makeOutputEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\r\n', 'log'),
+            makeOutputEvent('warning: (Error: pc 0x12345678 in address map, but not in symtab.)\n', 'log'),
+        ];
+        events.forEach(event => expect(eventFilter.filterOutputEvent(event)).toBe(true));
+    });
+
+    it('does not filter events with unexpected category', () => {
+        const events = [
+            makeOutputEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', 'stdout'),
+            makeOutputEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', 'stderr'),
+            makeOutputEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', 'console'),
+            makeOutputEvent('warning: (Internal error: pc 0x12345678 in read in CU, but not in symtab.)\n', undefined),
+        ];
+        events.forEach(event => expect(eventFilter.filterOutputEvent(event)).toBe(false));
+    });
+
+    it('does not filter events that do not match the regular expressions', () => {
+        const events = [
+            makeOutputEvent('foo', 'log'),
+            makeOutputEvent('warning: Internal error: pc 0x12345678 in read in CU, but not in symtab.\n', 'log'),
+            makeOutputEvent('Internal error: pc 0x12345678 in read in CU, but not in symtab.', 'log'),
+            makeOutputEvent('warning: (Internal error: pc in read in CU, but not in symtab.)\n', 'log'),
+        ];
+        events.forEach(event => expect(eventFilter.filterOutputEvent(event)).toBe(false));
+    });
+});
diff --git a/src/debug-session/output-event-filter.ts b/src/debug-session/output-event-filter.ts
@@ -0,0 +1,69 @@
+/**
+ * Copyright 2025 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DebugProtocol } from '@vscode/debugprotocol';
+
+/**
+ * OutputEventFilterSet - Defines a set of categories and messages that can apply together.
+ *
+ * Possible categories for `gdbtarget` debug adapter type:
+ *     'stdout' : GDB console stream
+ *     'stderr' : GDB stderr stream
+ *     'log' : GDB log stream
+ */
+interface OutputEventFilterSet {
+    categories: string[];
+    messages: RegExp[];
+}
+
+/**
+ * OutputEventFilter - Class to filter out specific output events based on
+ * active filter sets.
+ *
+ * Note: Not configurable at this time, extend constructor if more flexibility needed in future.
+ *
+ */
+export class OutputEventFilter {
+    private filterSets: OutputEventFilterSet[];
+
+    constructor() {
+        this.filterSets = [
+            {
+                // GDB warnings seen for (valid!!) DWARF 5 output where debug range
+                // addresses are assumed to be always code addresses.
+                categories: ['log'],
+                messages: [
+                    /warning: \(Internal error: pc 0x[0-9A-Fa-f]+ in read in CU, but not in symtab\.\)/,
+                    /warning: \(Error: pc 0x[0-9A-Fa-f]+ in address map, but not in symtab\.\)/,
+                ]
+            }
+        ];
+    }
+
+    /**
+     * Filters output event by specified filter sets.
+     *
+     * @param event The output event to process in the filter.
+     * @returns True if the event is to be discarded, false otherwise.
+     */
+    public filterOutputEvent(event: DebugProtocol.OutputEvent): boolean {
+        return this.filterSets.some(set => {
+            if (!set.categories.includes(event.body.category ?? '')) {
+                return false;
+            }
+            return set.messages.some(message => message.test(event.body.output));
+        });
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,9 @@ export class GDBTargetDebugTracker {`
`130`	`130`	`case 'exited':`
`131`	`131`	`gdbTargetSession?.refreshTimer.stop();`
`132`	`132`	`break;`
	`133`	`+ case 'output':`
	`134`	`+ gdbTargetSession?.filterOutputEvent(event as DebugProtocol.OutputEvent);`
	`135`	`+ break;`
`133`	`136`	`}`
`134`	`137`	`}`
`135`	`138`