Fix terminal escape symbols on OSX (#56)

* Initial implementation.

* Improve pty support for parallel execution of commands.

* Issue commands in parallel.

Fixes the slow execution of commands caused by the sequential execution of them.

* Fix getting state from the different controllers.

* [lldb] support `stdin`, `stdout` & `stderr` (#57)

* support `stdin`, `stdout` & `stderr`

* experimental: use LLDB API for I/O

---------

Co-authored-by: Vipul Cariappa <vipulcariappa@gmail.com>

Author: mvassilev

src/idd/cli.py

@@ -76,6 +76,7 @@ async def on_mount(self) -> None:
     async def set_command_result(self, version) -> None:
         state = Debugger.get_state(version)
 
+        await self.set_debugee_console_output(version)
         await self.set_pframes_result(state, version)
         await self.set_pargs_result(state, version)
         await self.set_plocals_result(state, version)
@@ -96,15 +97,27 @@ async def set_common_command_result(self, command_result) -> None:
             await self.set_pframes_command_result(state)
             await self.set_pargs_command_result(state)
             await self.set_plocals_command_result(state)
+            await self.set_debugee_console_output()
             if not self.disable_asm:
                 await self.set_pasm_command_result(state)
             if not self.disable_registers:
                 await self.set_pregisters_command_result(state)
 
             #calls = Debugger.get_current_calls()
 
+    async def set_debugee_console_output(self, target=None):
+        if target == "base":
+            result = Debugger.get_console_output(target)
+            self.diff_area1.append(result)
+        elif target == "regressed":
+            result = Debugger.get_console_output(target)
+            self.diff_area2.append(result)
+        else:
+            result = Debugger.get_console_output()
+            await self.compare_contents(result["base"], result["regressed"])
+
     async def compare_contents(self, raw_base_contents, raw_regression_contents):
-        if raw_base_contents != '' and raw_regression_contents != '':
+        if raw_base_contents or raw_regression_contents:
             diff1 = self.diff_driver.get_diff(raw_base_contents, raw_regression_contents, "base")
             self.diff_area1.append(diff1)
 
@@ -350,10 +363,10 @@ async def execute_debugger_command(self, event: Input.Changed) -> None:
                 exit(0)
 
             if self.parallel_command_bar.value.startswith("stdin "):
-                content = self.parallel_command_bar.value[6:]
-                Debugger.insert_stdin(content + "\n")
-                self.diff_area1.append([content])
-                self.diff_area2.append([content])
+                Debugger.insert_stdin(self.parallel_command_bar.value[6:] + "\n")
+                self.diff_area1.append([self.parallel_command_bar.value[6:]])
+                self.diff_area2.append([self.parallel_command_bar.value[6:]])
+
                 result = {}
 
             elif self.parallel_command_bar.value != "":
@@ -410,7 +423,7 @@ async def execute_debugger_command(self, event: Input.Changed) -> None:
         elif event.control.id == 'regressed-command-bar':
             if self.regressed_command_bar.value.startswith("stdin "):
                 Debugger.insert_stdin_single(self.regressed_command_bar.value[6:] + "\n", "regressed")
-                self.diff_area1.append([self.base_command_bar.value[6:]])
+                self.diff_area2.append([self.regressed_command_bar.value[6:]])
 
             elif self.regressed_command_bar.value != "":
                 result = Debugger.run_single_command(self.regressed_command_bar.value, "regressed")
@@ -516,12 +529,13 @@ def main() -> None:
 
     elif comparator == 'lldb':
         from idd.debuggers.lldb.lldb_driver import LLDBParallelDebugger, LLDBDebugger
+        from idd.debuggers.lldb.lldb_new_driver import LLDBNewDriver
 
         if ra == "" and rpid is None:
             Debugger = LLDBDebugger(ba, bpid)
             base_only = True
         else:
-            Debugger = LLDBParallelDebugger(ba, bpid, ra, rpid)
+            Debugger = LLDBNewDriver(ba, bpid, ra, rpid)
     else:
         sys.exit("Invalid comparator set")
 

src/idd/debuggers/lldb/lldb_controller.py

@@ -0,0 +1,104 @@
+import os, sys, pty, tty, select, threading
+import platform
+import lldb
+from lldb import eLaunchFlagStopAtEntry
+
+class IDDLLDBController:
+    def __init__(self, exe="", pid=None):
+        self.exe = exe
+        self.pid = pid
+        self.debugger = lldb.SBDebugger.Create()
+        self.debugger.SetAsync(False)
+        self.debugger.SetUseColor(False)
+
+        error = lldb.SBError()
+        self.target = self.debugger.CreateTarget(exe, platform.machine(), "host", True, error)
+        if not error.Success():
+            raise Exception(error.GetCString())
+
+        # self.master_fd, self.slave_fd = pty.openpty()
+        # self.slave_name = os.ttyname(self.slave_fd)
+        # tty.setraw(self.master_fd)
+
+        # self.debuggee_output = []
+        # self._start_output_stream_thread()
+
+        # self.target = self.debugger.CreateTarget(self.exe)
+        # if not self.target.IsValid():
+        #     raise Exception("Failed to create target")
+
+        # self._launch_process()
+
+    def _launch_process(self):
+        launch_info = lldb.SBLaunchInfo([])
+        # launch_info.SetArguments(["./tmp/main.py"], True)
+        # launch_info.SetWorkingDirectory(os.getcwd())
+        launch_info.SetLaunchFlags(eLaunchFlagStopAtEntry)
+
+        launch_info.AddOpenFileAction(0, self.slave_name, read=True, write=False)  # stdin
+        launch_info.AddOpenFileAction(1, self.slave_name, read=False, write=True)  # stdout
+        launch_info.AddOpenFileAction(2, self.slave_name, read=False, write=True)  # stderr
+
+        error = lldb.SBError()
+        self.process = self.target.Launch(launch_info, error)
+
+        if not error.Success():
+            raise Exception(f"Launch failed: {error.GetCString()}")
+
+    def _start_output_stream_thread(self):
+        def stream_output():
+            while True:
+                try:
+                    r, _, _ = select.select([self.master_fd], [], [], 0.1)
+                    if r:
+                        data = os.read(self.master_fd, 1024).decode(errors="replace")
+                        self.debuggee_output.append(data)
+                except OSError:
+                    break
+
+        self.output_thread = threading.Thread(target=stream_output, daemon=True)
+        self.output_thread.start()
+
+    # def write(self, command: str):
+    #     """Send LLDB command as if typed in interactive shell."""
+    #     if not command.endswith("\n"):
+    #         command += "\n"
+    #     os.write(self.master_fd, command.encode())
+
+    def run_lldb_command(self, command: str):
+        result = lldb.SBCommandReturnObject()
+        self.debugger.GetCommandInterpreter().HandleCommand(command, result)
+        if result.Succeeded():
+            return result.GetOutput().splitlines()
+        return result.GetError().splitlines()
+
+
+    def send_input_to_debuggee(self, text):
+        """Send input to the debugged process' stdin."""
+        # if not text.endswith("\n"):
+        #     text += "\n"
+        # os.write(self.master_fd, text.encode())
+        self.target.GetProcess().PutSTDIN(text)
+
+    def get_debuggee_output(self):
+        """Return all captured debuggee output so far."""
+        # os.set_blocking(self.master_fd, False)
+        # try:
+        #     content = os.read(self.master_fd, 1024 * 1024 * 10).decode(errors="replace")
+        # except BlockingIOError:
+        #     content = ""
+        # return content.splitlines()
+        return (self.target.GetProcess().GetSTDOUT(1024*1024*10) + self.target.GetProcess().GetSTDERR(1024*1024*10)).splitlines()
+
+    # def pop_output(self):
+    #     """Return and clear debuggee output buffer."""
+    #     output = self.debuggee_output
+    #     self.debuggee_output = []
+    #     return output
+
+    def terminate(self):
+        # if self.process:
+        #     self.process.Kill()
+        # os.close(self.master_fd)
+        # os.close(self.slave_fd)
+        lldb.SBDebugger.Destroy(self.debugger)

src/idd/debuggers/lldb/lldb_new_driver.py

@@ -0,0 +1,108 @@
+from idd.driver import Driver
+from idd.debuggers.lldb.lldb_controller import IDDLLDBController
+from idd.debuggers.lldb.lldb_extensions import *
+from concurrent.futures import ThreadPoolExecutor
+
+
+class LLDBNewDriver(Driver):
+    def __init__(
+        self, base_exe=None, base_pid=None, regressed_exe=None, regressed_pid=None
+    ):
+        self.base_controller = IDDLLDBController(exe=base_exe)
+        self.regressed_controller = IDDLLDBController(exe=regressed_exe)
+
+    def run_single_command(self, command, target):
+        if target == "base":
+            result = self.base_controller.run_lldb_command(command)
+            return result
+        elif target == "regressed":
+            result = self.regressed_controller.run_lldb_command(command)
+            return result
+
+    def run_parallel_command(self, command):
+        with ThreadPoolExecutor() as executor:
+            base_future = executor.submit(self.run_single_command, command, "base")
+            regressed_future = executor.submit(
+                self.run_single_command, command, "regressed"
+            )
+            return {
+                "base": base_future.result(),
+                "regressed": regressed_future.result(),
+            }
+
+    def insert_stdin(self, text):
+        self.base_controller.send_input_to_debuggee(text)
+        self.regressed_controller.send_input_to_debuggee(text)
+
+    def insert_stdin_single(self, text, target):
+        if target == "base":
+            self.base_controller.send_input_to_debuggee(text)
+        elif target == "regressed":
+            self.regressed_controller.send_input_to_debuggee(text)
+
+    def get_state(self, target=None):
+        if target == "base":
+            return {
+                "stack_frames": self.get_current_stack_frames(self.base_controller),
+                "locals": self.get_current_local_vars(self.base_controller, None),
+                "args": self.get_current_args(self.base_controller),
+                "instructions": self.get_current_instructions(self.base_controller),
+                "registers": self.get_current_registers(self.base_controller),
+            }
+        if target == "regressed":
+            return {
+                "stack_frames": self.get_current_stack_frames(self.regressed_controller),
+                "locals": self.get_current_local_vars(self.regressed_controller, None),
+                "args": self.get_current_args(self.regressed_controller),
+                "instructions": self.get_current_instructions(self.regressed_controller),
+                "registers": self.get_current_registers(self.regressed_controller),
+            }
+
+        with ThreadPoolExecutor() as executor:
+            base_future = executor.submit(self.get_state, "base")
+            regressed_future = executor.submit(self.get_state, "regressed")
+            return {
+                "base": base_future.result(),
+                "regressed": regressed_future.result(),
+            }
+        
+    def get_console_output(self, target=None):
+        if target == "base":
+            return self.base_controller.get_debuggee_output()
+        if target == "regressed":
+            return self.regressed_controller.get_debuggee_output()
+        
+        with ThreadPoolExecutor() as executor:
+            base_future = executor.submit(self.get_console_output, "base")
+            regressed_future = executor.submit(self.get_console_output, "regressed")
+            return {
+                "base": base_future.result(),
+                "regressed": regressed_future.result(),
+            }
+
+    def get_current_stack_frames(self, controller):
+        target = controller.debugger.GetTargetAtIndex(0)
+        return get_current_stack_frame_from_target(target) or []
+
+    def get_current_args(self, controller):
+        target = controller.debugger.GetTargetAtIndex(0)
+        return get_args_as_list(target) or []
+
+    def get_current_local_vars(self, controller, filters):
+        target = controller.debugger.GetTargetAtIndex(0)
+        locals = get_local_vars_as_list(target)
+        if filters == "ignore-order-declaration":
+            locals.sort()
+        return locals or []
+
+    def get_current_instructions(self, controller):
+        target = controller.debugger.GetTargetAtIndex(0)
+        return get_instructions_as_list(target) or []
+
+    def get_current_registers(self, controller):
+        target = controller.debugger.GetTargetAtIndex(0)
+        return get_registers_as_list(target) or []
+
+    def terminate(self):
+        self.base_controller.terminate()
+        self.regressed_controller.terminate()