[wip] Implementing debugger in xeus-cpp(Prototype)

CMakeLists.txt

@@ -180,6 +180,7 @@ else()
     configure_native_kernel("/share/jupyter/kernels/xcpp17/")
     configure_native_kernel("/share/jupyter/kernels/xcpp20/")
     configure_native_kernel("/share/jupyter/kernels/xcpp23/")
+    configure_native_kernel("/share/jupyter/kernels/xcpp17-debugger/")
 endif()
 
 # Source files
@@ -196,6 +197,7 @@ set(XEUS_CPP_HEADERS
     include/xeus-cpp/xmagics.hpp
     include/xeus-cpp/xoptions.hpp
     include/xeus-cpp/xpreamble.hpp
+    include/xeus-cpp/xdebugger.hpp
     #src/xinspect.hpp
     #src/xsystem.hpp
     #src/xparser.hpp
@@ -210,6 +212,9 @@ set(XEUS_CPP_SRC
     src/xparser.cpp
     src/xutils.cpp
     src/xmagics/os.cpp
+    src/xdebugger.cpp
+    src/xdebuglldb_client.cpp
+    src/xinternal_utils.cpp
 )
 
 if(NOT EMSCRIPTEN)

include/xeus-cpp/xdebugger.hpp

@@ -0,0 +1,105 @@
+/************************************************************************************
+ * Copyright (c) 2023, xeus-cpp contributors                                        *
+ * Copyright (c) 2023, Johan Mabille, Loic Gouarin, Sylvain Corlay, Wolf Vollprecht *
+ *                                                                                  *
+ * Distributed under the terms of the BSD 3-Clause License.                         *
+ *                                                                                  *
+ * The full license is in the file LICENSE, distributed with this software.         *
+ ************************************************************************************/
+
+#ifndef XEUS_CPP_DEBUGGER_HPP
+#define XEUS_CPP_DEBUGGER_HPP
+
+#ifdef __GNUC__
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wattributes"
+#endif
+
+#include <map>
+#include <mutex>
+#include <set>
+#include <string>
+
+#include "nlohmann/json.hpp"
+#include "xeus-zmq/xdebugger_base.hpp"
+#include "xeus_cpp_config.hpp"
+#include "xeus-cpp/xinterpreter.hpp"
+
+namespace xcpp
+{
+    class xdebuglldb_client;
+
+    class XEUS_CPP_API debugger : public xeus::xdebugger_base
+    {
+    public:
+
+        using base_type = xeus::xdebugger_base;
+
+        debugger(xeus::xcontext& context,
+                 const xeus::xconfiguration& config,
+                 const std::string& user_name,
+                 const std::string& session_id,
+                 const nl::json& debugger_config);
+
+        virtual ~debugger();
+
+    private:
+
+        nl::json inspect_variables_request(const nl::json& message);
+        nl::json stack_trace_request(const nl::json& message);
+        nl::json attach_request(const nl::json& message);
+        nl::json configuration_done_request(const nl::json& message);
+        nl::json set_breakpoints_request(const nl::json& message);
+        nl::json dump_cell_request(const nl::json& message);
+        nl::json rich_inspect_variables_request(const nl::json& message);
+        nl::json copy_to_globals_request(const nl::json& message);
+        nl::json source_request(const nl::json& message);
+
+        bool get_variable_info_from_lldb(const std::string& var_name, int frame_id, nl::json& data, nl::json& metadata, int sequence);
+        void get_container_info(const std::string& var_name, int frame_id, 
+                                 const std::string& var_type, nl::json& data, nl::json& metadata, int sequence, int size);
+        bool is_container_type(const std::string& type) const;
+
+        bool start_lldb();
+        bool start() override;
+        void stop() override;
+        xeus::xdebugger_info get_debugger_info() const override;
+        virtual std::string get_cell_temporary_file(const std::string& code) const override;
+
+        bool connect_to_lldb_tcp();
+        std::string send_dap_message(const nl::json& message);
+        std::string receive_dap_response();
+
+        xdebuglldb_client* p_debuglldb_client;
+        std::string m_lldb_host;
+        std::string m_lldb_port;
+        nl::json m_debugger_config;
+        bool m_is_running;
+        int m_tcp_socket;
+        bool m_tcp_connected;
+        pid_t jit_process_pid;
+
+        using breakpoint_list_t = std::map<std::string, std::vector<nl::json>>;
+        breakpoint_list_t m_breakpoint_list;
+
+        xcpp::interpreter* m_interpreter;
+
+        std::unordered_map<std::string, std::vector<std::string>> m_hash_to_sequential;
+        std::unordered_map<std::string, std::string> m_sequential_to_hash;
+
+        bool m_copy_to_globals_available;
+    };
+
+    XEUS_CPP_API
+    std::unique_ptr<xeus::xdebugger> make_cpp_debugger(xeus::xcontext& context,
+                                                       const xeus::xconfiguration& config,
+                                                       const std::string& user_name,
+                                                       const std::string& session_id,
+                                                       const nl::json& debugger_config);
+}
+
+#ifdef __GNUC__
+    #pragma GCC diagnostic pop
+#endif
+
+#endif

include/xeus-cpp/xinterpreter.hpp

@@ -25,6 +25,8 @@
 #include "xbuffer.hpp"
 #include "xeus_cpp_config.hpp"
 #include "xmanager.hpp"
+#include <thread>
+
 
 namespace nl = nlohmann;
 
@@ -40,6 +42,28 @@ namespace xcpp
         void publish_stdout(const std::string&);
         void publish_stderr(const std::string&);
 
+        static pid_t get_current_pid();
+
+        std::vector<int> get_execution_count(const std::string& code) const
+        {
+            auto it = m_code_to_execution_count_map.find(code);
+            if (it != m_code_to_execution_count_map.end())
+            {
+                return it->second;
+            }
+            return {};
+        }
+
+        std::string get_code_from_execution_count(int execution_count) const
+        {
+            auto it = m_execution_count_to_code_map.find(execution_count);
+            if(it != m_execution_count_to_code_map.end()) 
+            {
+                return it->second;
+            }
+            return "";
+        }
+
     private:
 
         void configure_impl() override;
@@ -85,6 +109,9 @@ namespace xcpp
 
         xoutput_buffer m_cout_buffer;
         xoutput_buffer m_cerr_buffer;
+
+        std::map<std::string, std::vector<int>> m_code_to_execution_count_map;
+        std::map<int, std::string> m_execution_count_to_code_map;
     };
 }
 

share/jupyter/kernels/xcpp17-debugger/kernel.json.in

@@ -0,0 +1,20 @@
+{
+  "display_name": "C++17-Debugger",
+  "env": {
+      "PATH":"@XEUS_CPP_PATH@",
+      "LD_LIBRARY_PATH":"@XEUS_CPP_LD_LIBRARY_PATH@"
+  },
+  "argv": [
+      "@XEUS_CPP_KERNELSPEC_PATH@xcpp",
+      "-f",
+      "{connection_file}",
+      "-g",
+      "-O0",
+      "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@",
+      "-I", "@XEUS_CPP_INCLUDE_DIR@",
+      "-std=c++17"
+  ],
+  "language": "cpp",
+  "metadata": {"debugger": true
+  }
+}

share/jupyter/kernels/xcpp17-omp/kernel.json.in

@@ -13,6 +13,6 @@
       "-std=c++17"@XEUS_CPP_OMP@
   ],
   "language": "cpp",
-  "metadata": {"debugger": false
+  "metadata": {"debugger": true
   }
 }

share/jupyter/kernels/xcpp17/wasm_kernel.json.in

@@ -8,7 +8,7 @@
   ],
   "language": "cpp",
   "metadata": {
-    "debugger": false,
+    "debugger": true,
     "shared": {
       "libxeus.so": "lib/libxeus.so",
       "libclangCppInterOp.so": "lib/libclangCppInterOp.so"

src/main.cpp

@@ -19,16 +19,19 @@
 #include <unistd.h>
 #endif
 
-#include "xeus/xhelper.hpp"
+#include "nlohmann/json.hpp"
+#include <xeus/xhelper.hpp>
 #include <xeus/xkernel.hpp>
 #include <xeus/xkernel_configuration.hpp>
-
 #include "xeus-zmq/xzmq_context.hpp"
 #include <xeus-zmq/xserver_zmq.hpp>
-
+#include "xeus-zmq/xserver_zmq_split.hpp"
 #include "xeus-cpp/xeus_cpp_config.hpp"
 #include "xeus-cpp/xinterpreter.hpp"
 #include "xeus-cpp/xutils.hpp"
+#include "xeus-cpp/xdebugger.hpp"
+
+namespace nl = nlohmann;
 
 int main(int argc, char* argv[])
 {
@@ -62,6 +65,12 @@ int main(int argc, char* argv[])
     auto interpreter = std::make_unique<xcpp::interpreter>(argc, argv);
     std::unique_ptr<xeus::xcontext> context = xeus::make_zmq_context();
 
+    nl::json debugger_config;
+    debugger_config["lldb"]["initCommands"] = {
+        "settings set plugin.jit-loader.gdb.enable on"
+    };
+    debugger_config["interpreter_ptr"] = reinterpret_cast<std::uintptr_t>(interpreter.get());
+
     if (!file_name.empty())
     {
         xeus::xconfiguration config = xeus::load_configuration(file_name);
@@ -72,18 +81,19 @@ int main(int argc, char* argv[])
             xeus::get_user_name(),
             std::move(context),
             std::move(interpreter),
-            xeus::make_xserver_default,
+            xeus::make_xserver_control_main,
             xeus::make_in_memory_history_manager(),
             xeus::make_console_logger(
                 xeus::xlogger::msg_type,
                 xeus::make_file_logger(xeus::xlogger::content, "xeus.log")
-            )
+            ),
+            xcpp::make_cpp_debugger,
+            debugger_config
         );
 
         std::clog << "Starting xcpp kernel...\n\n"
                      "If you want to connect to this kernel from an other client, you can use"
-                     " the "
-                         + file_name + " file."
+                     " the " + file_name + " file."
                   << std::endl;
 
         kernel.start();
@@ -94,12 +104,14 @@ int main(int argc, char* argv[])
             xeus::get_user_name(),
             std::move(context),
             std::move(interpreter),
-            xeus::make_xserver_default,
+            xeus::make_xserver_control_main,
             xeus::make_in_memory_history_manager(),
             xeus::make_console_logger(
                 xeus::xlogger::msg_type,
                 xeus::make_file_logger(xeus::xlogger::content, "xeus.log")
-            )
+            ),
+            xcpp::make_cpp_debugger,
+            debugger_config
         );
 
         std::cout << "Getting config" << std::endl;
@@ -109,37 +121,20 @@ int main(int argc, char* argv[])
                      " and paste the following content inside of a `kernel.json` file. And then run for example:\n\n"
                      "# jupyter console --existing kernel.json\n\n"
                      "kernel.json\n```\n{\n"
-                     "    \"transport\": \""
-                         + config.m_transport
-                         + "\",\n"
-                           "    \"ip\": \""
-                         + config.m_ip
-                         + "\",\n"
-                           "    \"control_port\": "
-                         + config.m_control_port
-                         + ",\n"
-                           "    \"shell_port\": "
-                         + config.m_shell_port
-                         + ",\n"
-                           "    \"stdin_port\": "
-                         + config.m_stdin_port
-                         + ",\n"
-                           "    \"iopub_port\": "
-                         + config.m_iopub_port
-                         + ",\n"
-                           "    \"hb_port\": "
-                         + config.m_hb_port
-                         + ",\n"
-                           "    \"signature_scheme\": \""
-                         + config.m_signature_scheme
-                         + "\",\n"
-                           "    \"key\": \""
-                         + config.m_key
-                         + "\"\n"
-                           "}\n```\n";
+                     "    \"transport\": \"" + config.m_transport + "\",\n"
+                     "    \"ip\": \"" + config.m_ip + "\",\n"
+                     "    \"control_port\": " + config.m_control_port + ",\n"
+                     "    \"shell_port\": " + config.m_shell_port + ",\n"
+                     "    \"stdin_port\": " + config.m_stdin_port + ",\n"
+                     "    \"iopub_port\": " + config.m_iopub_port + ",\n"
+                     "    \"hb_port\": " + config.m_hb_port + ",\n"
+                     "    \"signature_scheme\": \"" + config.m_signature_scheme + "\",\n"
+                     "    \"key\": \"" + config.m_key + "\"\n"
+                     "}\n```"
+                  << std::endl;
 
         kernel.start();
     }
 
     return 0;
-}
+}