[lldb/Interpreter] Introduce ScriptedPlatform{,Python}Interface

[mib]

Summary

This patch introduces both the ScriptedPlatformInterface and the
ScriptedPlatformPythonInterface. As the name suggests, these calls will
be used to call into the Scripted Platform python implementation from
the C++ Scripted Platform plugin instance.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[bulbazord]

lldb/include/lldb/Interpreter/ScriptedPlatformInterface.h

14

What is MemoryRegionInfo.h for?

36–42

The status messages should probably refer to ScriptedPlatformInterface instead of ScriptedPlatform to be clearer.

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPlatformPythonInterface.cpp

1–2

This header is also broken.

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPlatformPythonInterface.h

1–2

The header is a little broken here.

[mib]

Address @bulbazord comments

[bulbazord]

LGTM

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPlatformPythonInterface.cpp

98

nit: This #endif should have a // LLDB_ENABLE_PYTHON at the end of it to be consistent style-wise.

[mib]

Add AttachToProcess method to interface

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 #include "lldb/API/SBError.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadedCommunication.h"
 #include "lldb/Host/PseudoTerminal.h"
+#include "lldb/Interpreter/ScriptedPlatformInterface.h"
 #include "lldb/Interpreter/ScriptedProcessInterface.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
enum ScriptReturnType {
     eScriptReturnTypeChar,
     eScriptReturnTypeCharStrOrNone,
     eScriptReturnTypeOpaqueObject
   };
 
   ScriptInterpreter(
       Debugger &debugger, lldb::ScriptLanguage script_lang,
       lldb::ScriptedProcessInterfaceUP scripted_process_interface_up =
-          std::make_unique<ScriptedProcessInterface>());
+          std::make_unique<ScriptedProcessInterface>(),
+      lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up =
+          std::make_unique<ScriptedPlatformInterface>());
 
   virtual StructuredData::DictionarySP GetInterpreterInfo();
 
   ~ScriptInterpreter() override = default;
 
   virtual bool Interrupt() { return false; }
 
   virtual bool ExecuteOneLine(
public:
   static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
 
   lldb::ScriptLanguage GetLanguage() { return m_script_lang; }
 
   ScriptedProcessInterface &GetScriptedProcessInterface() {
     return *m_scripted_process_interface_up;
   }
 
+  ScriptedPlatformInterface &GetScriptedPlatformInterface() {
+    return *m_scripted_platform_interface_up;
+  }
+
   lldb::DataExtractorSP
   GetDataExtractorFromSBData(const lldb::SBData &data) const;
 
   Status GetStatusFromSBError(const lldb::SBError &error) const;
 
   llvm::Optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
       const lldb::SBMemoryRegionInfo &mem_region) const;
 
 protected:
   Debugger &m_debugger;
   lldb::ScriptLanguage m_script_lang;
   lldb::ScriptedProcessInterfaceUP m_scripted_process_interface_up;
+  lldb::ScriptedPlatformInterfaceUP m_scripted_platform_interface_up;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H

lldb/include/lldb/Interpreter/ScriptedPlatformInterface.h

+//===-- ScriptedPlatformInterface.h -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_INTERPRETER_SCRIPTEDPLATFORMINTERFACE_H
+#define LLDB_INTERPRETER_SCRIPTEDPLATFORMINTERFACE_H
+
+#include "lldb/Core/StructuredDataImpl.h"
+#include "lldb/Interpreter/ScriptedInterface.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+
+#include "lldb/lldb-private.h"
+
+#include <string>
+
+namespace lldb_private {
+class ScriptedPlatformInterface : virtual public ScriptedInterface {
+public:
+  StructuredData::GenericSP
+  CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
+                     StructuredData::DictionarySP args_sp,
+                     StructuredData::Generic *script_obj = nullptr) override {
+    return {};
+  }
+
+  virtual StructuredData::DictionarySP ListProcesses() { return {}; }
+
+  virtual StructuredData::DictionarySP GetProcessInfo(lldb::pid_t) {
+    return {};
+  }
+
+  virtual Status LaunchProcess() {
+    return Status("ScriptedPlatform cannot launch process");
+  }
+
+  virtual Status KillProcess(lldb::pid_t pid) {
+    return Status("ScriptedPlatform cannot kill process");
+  }
+};
+} // namespace lldb_private
+
+#endif // LLDB_INTERPRETER_SCRIPTEDPLATFORMINTERFACE_H

lldb/include/lldb/lldb-forward.h

 class RegisterCheckpoint;
 class RegisterContext;
 class RegisterValue;
 class RegularExpression;
 class RichManglingContext;
 class Scalar;
 class ScriptInterpreter;
 class ScriptInterpreterLocker;
+class ScriptedPlatformInterface;
 class ScriptedProcessInterface;
 class ScriptedThreadInterface;
 class ScriptedSyntheticChildren;
 class SearchFilter;
 class Section;
 class SectionList;
 class SectionLoadHistory;
 class SectionLoadList;

 typedef std::weak_ptr<lldb_private::Queue> QueueWP;
 typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;
 typedef std::shared_ptr<lldb_private::REPL> REPLSP;
 typedef std::shared_ptr<lldb_private::RecognizedStackFrame>
     RecognizedStackFrameSP;
 typedef std::shared_ptr<lldb_private::ScriptSummaryFormat>
     ScriptSummaryFormatSP;
 typedef std::shared_ptr<lldb_private::ScriptInterpreter> ScriptInterpreterSP;
+typedef std::unique_ptr<lldb_private::ScriptedPlatformInterface>
+    ScriptedPlatformInterfaceUP;
 typedef std::unique_ptr<lldb_private::ScriptedProcessInterface>
     ScriptedProcessInterfaceUP;
 typedef std::shared_ptr<lldb_private::ScriptedThreadInterface>
     ScriptedThreadInterfaceSP;
 typedef std::shared_ptr<lldb_private::Section> SectionSP;
 typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;
 typedef std::weak_ptr<lldb_private::Section> SectionWP;
 typedef std::shared_ptr<lldb_private::SectionLoadList> SectionLoadListSP;

lldb/source/Interpreter/ScriptInterpreter.cpp

 #include <memory>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 
 ScriptInterpreter::ScriptInterpreter(
     Debugger &debugger, lldb::ScriptLanguage script_lang,
-    lldb::ScriptedProcessInterfaceUP scripted_process_interface_up)
+    lldb::ScriptedProcessInterfaceUP scripted_process_interface_up,
+    lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up)
     : m_debugger(debugger), m_script_lang(script_lang),
-      m_scripted_process_interface_up(
-          std::move(scripted_process_interface_up)) {}
+      m_scripted_process_interface_up(std::move(scripted_process_interface_up)),
+      m_scripted_platform_interface_up(
+          std::move(scripted_platform_interface_up)) {}
 
 void ScriptInterpreter::CollectDataForBreakpointCommandCallback(
     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
     CommandReturnObject &result) {
   result.AppendError(
       "This script interpreter does not support breakpoint callbacks.");
 }
 

lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt

 
 add_lldb_library(lldbPluginScriptInterpreterPython PLUGIN
   PythonDataObjects.cpp
   PythonReadline.cpp
   ScriptInterpreterPython.cpp
   ScriptedPythonInterface.cpp
   ScriptedProcessPythonInterface.cpp
   ScriptedThreadPythonInterface.cpp
+  ScriptedPlatformPythonInterface.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbInterpreter
     lldbTarget
     ${Python3_LIBRARIES}
     ${LLDB_LIBEDIT_LIBS}
 
   LINK_COMPONENTS
     Support
   )

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "PythonReadline.h"
 #include "SWIGPythonBridge.h"
 #include "ScriptInterpreterPythonImpl.h"
+#include "ScriptedPlatformPythonInterface.h"
 #include "ScriptedProcessPythonInterface.h"
 
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/WatchpointOptions.h"
 #include "lldb/Core/Debugger.h"
: ScriptInterpreterPython(debugger), m_saved_stdin(), m_saved_stdout(),
       m_sys_module_dict(PyInitialValue::Invalid), m_run_one_line_function(),
       m_run_one_line_str_global(),
       m_dictionary_name(m_debugger.GetInstanceName().AsCString()),
       m_active_io_handler(eIOHandlerNone), m_session_is_active(false),
       m_pty_secondary_is_open(false), m_valid_session(true), m_lock_count(0),
       m_command_thread_state(nullptr) {
   m_scripted_process_interface_up =
       std::make_unique<ScriptedProcessPythonInterface>(*this);
+  m_scripted_platform_interface_up =
+      std::make_unique<ScriptedPlatformPythonInterface>(*this);
 
   m_dictionary_name.append("_dict");
   StreamString run_string;
   run_string.Printf("%s = dict()", m_dictionary_name.c_str());
 
   Locker locker(this, Locker::AcquireLock, Locker::FreeAcquiredLock);
   PyRun_SimpleString(run_string.GetData());
 

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPlatformPythonInterface.h

+//===-- ScriptedPlatformPythonInterface.h ------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPLATFORMPYTHONINTERFACE_H
+#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPLATFORMPYTHONINTERFACE_H
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+#include "ScriptedPythonInterface.h"
+#include "lldb/Interpreter/ScriptedPlatformInterface.h"
+
+namespace lldb_private {
+class ScriptedPlatformPythonInterface : public ScriptedPlatformInterface,
+                                        public ScriptedPythonInterface {
+public:
+  ScriptedPlatformPythonInterface(ScriptInterpreterPythonImpl &interpreter);
+
+  StructuredData::GenericSP
+  CreatePluginObject(const llvm::StringRef class_name,
+                     ExecutionContext &exe_ctx,
+                     StructuredData::DictionarySP args_sp,
+                     StructuredData::Generic *script_obj = nullptr) override;
+
+  StructuredData::DictionarySP ListProcesses() override;
+
+  StructuredData::DictionarySP GetProcessInfo(lldb::pid_t) override;
+
+  Status LaunchProcess() override;
+
+  Status KillProcess(lldb::pid_t pid) override;
+};
+} // namespace lldb_private
+
+#endif // LLDB_ENABLE_PYTHON
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPLATFORMPYTHONINTERFACE_H

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPlatformPythonInterface.cpp

+//===-- ScriptedPlatformPythonInterface.cpp
+//--------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Config.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-enumerations.h"
+
+#if LLDB_ENABLE_PYTHON
+
+// LLDB Python header must be included first
+#include "lldb-python.h"
+
+#include "SWIGPythonBridge.h"
+#include "ScriptInterpreterPythonImpl.h"
+#include "ScriptedPlatformPythonInterface.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::python;
+using Locker = ScriptInterpreterPythonImpl::Locker;
+
+ScriptedPlatformPythonInterface::ScriptedPlatformPythonInterface(
+    ScriptInterpreterPythonImpl &interpreter)
+    : ScriptedPlatformInterface(), ScriptedPythonInterface(interpreter) {}
+
+StructuredData::GenericSP ScriptedPlatformPythonInterface::CreatePluginObject(
+    llvm::StringRef class_name, ExecutionContext &exe_ctx,
+    StructuredData::DictionarySP args_sp, StructuredData::Generic *script_obj) {
+  if (class_name.empty())
+    return {};
+
+  StructuredDataImpl args_impl(args_sp);
+  std::string error_string;
+
+  Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
+                 Locker::FreeLock);
+
+  PythonObject ret_val = LLDBSwigPythonCreateScriptedPlatform(
+      class_name.str().c_str(), m_interpreter.GetDictionaryName(), args_impl,
+      error_string);
+
+  m_object_instance_sp =
+      StructuredData::GenericSP(new StructuredPythonObject(std::move(ret_val)));
+
+  return m_object_instance_sp;
+}
+
+StructuredData::DictionarySP ScriptedPlatformPythonInterface::ListProcesses() {
+  Status error;
+  StructuredData::DictionarySP dict_sp =
+      Dispatch<StructuredData::DictionarySP>("list_processes", error);
+
+  if (!dict_sp || !dict_sp->IsValid() || error.Fail()) {
+    return ScriptedInterface::ErrorWithMessage<StructuredData::DictionarySP>(
+        LLVM_PRETTY_FUNCTION,
+        llvm::Twine("Null or invalid object (" +
+                    llvm::Twine(error.AsCString()) + llvm::Twine(")."))
+            .str(),
+        error);
+  }
+
+  return dict_sp;
+}
+
+StructuredData::DictionarySP
+ScriptedPlatformPythonInterface::GetProcessInfo(lldb::pid_t pid) {
+  Status error;
+  StructuredData::DictionarySP dict_sp =
+      Dispatch<StructuredData::DictionarySP>("get_process_info", error, pid);
+
+  if (!dict_sp || !dict_sp->IsValid() || error.Fail()) {
+    return ScriptedInterface::ErrorWithMessage<StructuredData::DictionarySP>(
+        LLVM_PRETTY_FUNCTION,
+        llvm::Twine("Null or invalid object (" +
+                    llvm::Twine(error.AsCString()) + llvm::Twine(")."))
+            .str(),
+        error);
+  }
+
+  return dict_sp;
+}
+
+Status ScriptedPlatformPythonInterface::LaunchProcess() {
+  return GetStatusFromMethod("launch_process");
+}
+
+Status ScriptedPlatformPythonInterface::KillProcess(lldb::pid_t pid) {
+  return GetStatusFromMethod("kill_process", pid);
+}
+
+#endif