Add multi-process support

package.json

@@ -204,6 +204,11 @@
 								"description": "Prints all GDB calls to the console",
 								"default": false
 							},
+							"multiProcess": {
+								"type": "boolean",
+								"description": "Allow multiple process debugging",
+								"default": false
+							},
 							"showDevDebugOutput": {
 								"type": "boolean",
 								"description": "Prints all GDB responses to the console",

src/backend/backend.ts

@@ -64,8 +64,8 @@ export interface IBackend {
 	start(runToStart: boolean): Thenable<boolean>;
 	stop(): void;
 	detach(): void;
-	interrupt(): Thenable<boolean>;
-	continue(): Thenable<boolean>;
+	interrupt(threadId?: number): Thenable<boolean>;
+	continue(reverse?: boolean, threadId?: number): Thenable<boolean>;
 	next(): Thenable<boolean>;
 	step(): Thenable<boolean>;
 	stepOut(): Thenable<boolean>;

src/backend/mi2/mi2.ts

@@ -250,7 +250,7 @@
 			target = debuggerPath.join(cwd, target);
 
 		const cmds = [
-			this.sendCommand("gdb-set target-async on", true),
+			this.sendCommand("gdb-set mi-async on", true),
 			new Promise(resolve => {
 				this.sendCommand("list-features").then(done => {
 					this.features = done.result("features");
@@ -269,6 +269,16 @@
 			cmds.push(this.sendCommand("enable-pretty-printing"));
 		if (this.frameFilters)
 			cmds.push(this.sendCommand("enable-frame-filters"));
+		if (this.multiProcess) {
+			cmds.push(
+			  this.sendCommand("gdb-set follow-fork-mode parent"),
+				this.sendCommand("gdb-set detach-on-fork off"),
+				this.sendCommand("gdb-set non-stop on"),
+				this.sendCommand("gdb-set schedule-multiple on"),
+
+				this.sendCommand("interpreter-exec console \"handle SIGSYS nostop noprint\"")
+			);
+		}
 		for (const cmd of this.extraCommands) {
 			cmds.push(this.sendCommand(cmd));
 		}
@@ -462,7 +472,7 @@
 												this.emit("exited-normally", parsed);
 												break;
 											case "exited": // exit with error code != 0
-												this.log("stderr", "Program exited with code " + parsed.record("exit-code"));
+												this.log("stderr", "Inferior exited with code " + parsed.record("exit-code"));
 												this.emit("exited-normally", parsed);
 												break;
 												// case "exited-signalled":	// consider handling that explicit possible
@@ -483,6 +493,10 @@
 									this.emit("thread-created", parsed);
 								} else if (record.asyncClass === "thread-exited") {
 									this.emit("thread-exited", parsed);
+								} else if (record.asyncClass == "thread-group-started") {
+									this.emit("thread-group-started", parsed);
+								} else if (record.asyncClass == "thread-group-exited") {
+									this.emit("thread-group-exited", parsed);
 								}
 							}
 						}
@@ -546,21 +560,21 @@
 		this.sendRaw("-target-detach");
 	}
 
-	interrupt(): Thenable<boolean> {
+	interrupt(threadId?: number): Thenable<boolean> {
 		if (trace)
-			this.log("stderr", "interrupt");
+			this.log("stderr", "interrupt" + (threadId ? " --thread-group i" + threadId : ""));
 		return new Promise((resolve, reject) => {
-			this.sendCommand("exec-interrupt").then((info) => {
+			this.sendCommand("exec-interrupt" + (threadId ? " --thread-group i" + threadId : "")).then((info) => {
 				resolve(info.resultRecords.resultClass === "done");
 			}, reject);
 		});
 	}
 
-	continue(reverse: boolean = false): Thenable<boolean> {
+	continue(reverse: boolean = false, threadId?: number): Thenable<boolean> {
 		if (trace)
-			this.log("stderr", "continue");
+			this.log("stderr", "continue" + (reverse ? " --reverse" : "") + (threadId ? " --thread-group i" + threadId : ""));
 		return new Promise((resolve, reject) => {
-			this.sendCommand("exec-continue" + (reverse ? " --reverse" : "")).then((info) => {
+			this.sendCommand("exec-continue" + (reverse ? " --reverse" : "") + (threadId ? " --thread-group i" + threadId : "")).then((info) => {
 				resolve(info.resultRecords.resultClass === "running");
 			}, reject);
 		});
@@ -1023,6 +1037,7 @@
 
 	prettyPrint: boolean = true;
 	frameFilters: boolean = true;
+	multiProcess: boolean = false;
 	printCalls: boolean;
 	debugOutput: boolean;
 	features: string[];

src/backend/mi2/mi2inferior.ts

@@ -0,0 +1,101 @@
+import { Breakpoint, IBackend, SSHArguments, Stack, Thread, Variable } from "../backend";
+import { MI2 } from "./mi2";
+
+export class MI2Inferior implements IBackend {
+	load(cwd: string, target: string, procArgs: string, separateConsole: string, autorun: string[]): Thenable<any> {
+		return this.superior.load(cwd, target, procArgs, separateConsole, autorun);
+	}
+
+	ssh(args: SSHArguments, cwd: string, target: string, procArgs: string, separateConsole: string, attach: boolean, autorun: string[]): Thenable<any> {
+		return this.superior.ssh(args, cwd, target, separateConsole, procArgs, attach, autorun);
+	}
+
+	attach(cwd: string, executable: string, target: string, autorun: string[]): Thenable<any> {
+		return this.superior.attach(cwd, executable, target, autorun);
+	}
+
+	connect(cwd: string, executable: string, target: string, autorun: string[]): Thenable<any> {
+		return this.superior.attach(cwd, executable, target, autorun);
+	}
+
+	start(runToStart: boolean): Thenable<boolean> {
+		return this.superior.start(runToStart);
+	}
+
+	stop(): void {
+		this.superior.stop();
+	}
+
+	detach(): void {
+		this.superior.detach();
+	}
+
+	interrupt(threadId?: number): Thenable<boolean> {
+		return this.superior.interrupt(threadId);
+	}
+
+	continue(reverse?: boolean, threadId?: number): Thenable<boolean> {
+		return this.superior.continue(reverse, threadId);
+	}
+
+	next(): Thenable<boolean> {
+		return this.superior.next();
+	}
+	step(): Thenable<boolean> {
+		return this.superior.step();
+	}
+
+	stepOut(): Thenable<boolean> {
+		return this.superior.stepOut();
+	}
+
+	loadBreakPoints(breakpoints: Breakpoint[]): Thenable<[boolean, Breakpoint][]> {
+		return this.superior.loadBreakPoints(breakpoints);
+	}
+
+	addBreakPoint(breakpoint: Breakpoint): Thenable<[boolean, Breakpoint]> {
+		return this.superior.addBreakPoint(breakpoint);
+	}
+
+	removeBreakPoint(breakpoint: Breakpoint): Thenable<boolean> {
+		return this.superior.removeBreakPoint(breakpoint);
+	}
+
+	clearBreakPoints(source?: string): Thenable<any> {
+		return this.superior.clearBreakPoints(source);
+	}
+
+	getThreads(): Thenable<Thread[]> {
+		return this.superior.getThreads();
+	}
+
+	getStack(startFrame: number, maxLevels: number, thread: number): Thenable<Stack[]> {
+		return this.superior.getStack(startFrame, maxLevels, thread);
+	}
+
+	getStackVariables(thread: number, frame: number): Thenable<Variable[]> {
+		return this.superior.getStackVariables(thread, frame);
+	}
+
+	evalExpression(name: string, thread: number, frame: number): Thenable<any> {
+		return this.superior.evalExpression(name, thread, frame);
+	}
+
+	isReady(): boolean {
+		return this.superior.isReady();
+	}
+
+	changeVariable(name: string, rawValue: string): Thenable<any> {
+		return this.superior.changeVariable(name, rawValue);
+	}
+
+	examineMemory(from: number, to: number): Thenable<any> {
+		return this.superior.examineMemory(from, to);
+	}
+
+	private superior: MI2;
+
+	contructor(superior: MI2) {
+		this.superior = superior
+	}
+};

src/gdb.ts

@@ -19,6 +19,7 @@ export interface LaunchRequestArguments extends DebugProtocol.LaunchRequestArgum
 	valuesFormatting: ValuesFormattingMode;
 	frameFilters: boolean;
 	printCalls: boolean;
+	multiProcess: boolean;
 	showDevDebugOutput: boolean;
 	registerLimit: string;
 }
@@ -39,11 +40,12 @@ export interface AttachRequestArguments extends DebugProtocol.AttachRequestArgum
 	valuesFormatting: ValuesFormattingMode;
 	frameFilters: boolean;
 	printCalls: boolean;
+	multiProcess: boolean;
 	showDevDebugOutput: boolean;
 	registerLimit: string;
 }
 
-class GDBDebugSession extends MI2DebugSession {
+export class GDBDebugSession extends MI2DebugSession {
 	protected override initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void {
 		response.body.supportsGotoTargetsRequest = true;
 		response.body.supportsHitConditionalBreakpoints = true;
@@ -75,6 +77,7 @@ class GDBDebugSession extends MI2DebugSession {
 		this.setValuesFormattingMode(args.valuesFormatting);
 		this.miDebugger.frameFilters = !!args.frameFilters;
 		this.miDebugger.printCalls = !!args.printCalls;
+		this.miDebugger.multiProcess = !!args.multiProcess;
 		this.miDebugger.debugOutput = !!args.showDevDebugOutput;
 		this.stopAtEntry = args.stopAtEntry;
 		this.miDebugger.registerLimit = args.registerLimit ?? "";
@@ -121,6 +124,7 @@ class GDBDebugSession extends MI2DebugSession {
 		this.setValuesFormattingMode(args.valuesFormatting);
 		this.miDebugger.frameFilters = !!args.frameFilters;
 		this.miDebugger.printCalls = !!args.printCalls;
+		this.miDebugger.multiProcess = !!args.multiProcess;
 		this.miDebugger.debugOutput = !!args.showDevDebugOutput;
 		this.stopAtEntry = args.stopAtEntry;
 		this.miDebugger.registerLimit = args.registerLimit ?? "";