[lldb/Lua] Add Boilerplate for a Lua Script Interpreter

[JDevlieghere]

Summary

This adds the boilerplate necessary to support the Lua script interpreter. The interpreter itself is non-functional and just says it's not yet implemented.

Discussion on the mailing list:http://lists.llvm.org/pipermail/lldb-dev/2019-December/015812.html

[JDevlieghere]

Return the right name from GetPluginNameStatic.

[xiaobai]

I'm really excited to see where this goes! :D

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

65

Why is this Null and not Lua? :P

[labath]

lldb/cmake/modules/LLDBConfig.cmake

27

I think this will tick off some bots (and people) because it means that the default configuration will not build unless one has (compatible?) lua installed. Though I don't really like that, the usual way to handle external dependencies in llvm is to detect their presence and automatically disable the relevant functionality.

Now, that's not how things work in lldb right now, so it _may_ make sense to do the same for lua (though it also may make sense to port everything to the llvm style). However, the current lldb behavior has been a source of friction in the past and I suspect a fresh build error might reignite some of that.

Anyway, you have been warned...

337

Can we replace this (and maybe python too, while at it) with a Host/Config.h entry? A global definition means that one has to recompile everything when these change in any way, whereas in practice only a handful of files need this..

[mgorny]

lldb/cmake/modules/LLDBConfig.cmake

27

Fixing this is one of the things at the far end of my todo. If you could look into replacing the disable logic with something better, a lot of people would really be grateful.

[JDevlieghere]

lldb/cmake/modules/LLDBConfig.cmake

27

I've changed the default for now and put up an "RFC" here: https://reviews.llvm.org/D71306

[JDevlieghere]

Reuse IOHandlerEditline for the Lua interpreter.

[JDevlieghere]

^ updated the wrong patch

[JDevlieghere]

Rebase

[labath]

Given the positive response to the RFC, I think we can start landing this stuff.

lldb/cmake/modules/LLDBConfig.cmake

27

That's cool. I think this can stay as off until we deal with the deal with the dependency problem

[labath]

lldb/cmake/modules/LLDBConfig.cmake

62

Umm... I guess this wanted to be LLDB_ENABLE_LUA ?

lldb/cmake/modules/LLDBConfig.cmake

 endif()
 
 set(LLDB_LINKER_SUPPORTS_GROUPS OFF)
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
   # The Darwin linker doesn't understand --start-group/--end-group.
   set(LLDB_LINKER_SUPPORTS_GROUPS ON)
 endif()
 
 set(default_enable_python ON)
+set(default_enable_lua OFF) # Experimental
 set(default_enable_libedit ON)
 set(default_enable_curses ON)
 
 # Temporary support the old LLDB_DISABLE_* variables
 if (DEFINED LLDB_DISABLE_CURSES)
   if (LLDB_DISABLE_CURSES)
     set(default_enable_curses OFF)
   endif()
 endif()
 if (DEFINED LLDB_DISABLE_PYTHON)
   if (LLDB_DISABLE_PYTHON)
     set(default_enable_python OFF)
   endif()
 endif()
 
 if(DEFINED LLVM_ENABLE_LIBEDIT AND NOT LLVM_ENABLE_LIBEDIT)
   set(default_disable_libedit ON)
 endif()
 
 if(CMAKE_SYSTEM_NAME MATCHES "Windows")
   set(default_enable_libedit OFF)
   set(default_enable_curses OFF)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Android")
   set(default_enable_python OFF)
+  set(default_enable_lua OFF)
   set(default_enable_libedit OFF)
   set(default_enable_curses OFF)
 elseif(IOS)
   set(default_enable_python OFF)
+  set(default_enable_lua OFF)
 endif()
 
 option(LLDB_ENABLE_PYTHON "Enable Python scripting integration." ${default_enable_python})
+option(LLDB_ENABLE_PYTHON "Enable Lua scripting integration." ${default_enable_lua})
 option(LLDB_ENABLE_LIBEDIT "Enable the use of editline." ${default_enable_libedit})
 option(LLDB_ENABLE_CURSES "Enable Curses integration." ${default_enable_curses})
 option(LLDB_RELOCATABLE_PYTHON "Use the PYTHONHOME environment variable to locate Python." OFF)
 option(LLDB_USE_SYSTEM_SIX "Use six.py shipped with system and do not install a copy of it" OFF)
 option(LLDB_USE_ENTITLEMENTS "When codesigning, use entitlements if available" ON)
 option(LLDB_BUILD_FRAMEWORK "Build LLDB.framework (Darwin only)" OFF)
 option(LLDB_NO_INSTALL_DEFAULT_RPATH "Disable default RPATH settings in binaries" OFF)
 option(LLDB_USE_SYSTEM_DEBUGSERVER "Use the system's debugserver for testing (Darwin only)." OFF)

 
 if (NOT LLDB_ENABLE_PYTHON)
   unset(PYTHON_INCLUDE_DIR)
   unset(PYTHON_LIBRARY)
   unset(PYTHON_EXECUTABLE)
 endif()
 
 if (LLVM_EXTERNAL_CLANG_SOURCE_DIR)
   include_directories(${LLVM_EXTERNAL_CLANG_SOURCE_DIR}/include)
 else ()
   include_directories(${CMAKE_SOURCE_DIR}/tools/clang/include)
 endif ()
 include_directories("${CMAKE_CURRENT_BINARY_DIR}/../clang/include")
 
 # Disable GCC warnings
 check_cxx_compiler_flag("-Wno-deprecated-declarations"
                         CXX_SUPPORTS_NO_DEPRECATED_DECLARATIONS)

lldb/include/lldb/Host/Config.h.cmake

 #cmakedefine01 LLDB_ENABLE_LZMA
 
 #cmakedefine01 LLDB_ENABLE_CURSES
 
 #cmakedefine01 LLDB_ENABLE_LIBEDIT
 
 #cmakedefine01 LLDB_ENABLE_LIBXML2
 
+#cmakedefine01 LLDB_ENABLE_LUA
+
 #cmakedefine01 LLDB_ENABLE_PYTHON
 
 #cmakedefine LLDB_PYTHON_HOME "${LLDB_PYTHON_HOME}"
 
 #define LLDB_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}"
 
 #endif // #ifndef LLDB_HOST_CONFIG_H

lldb/include/lldb/lldb-enumerations.h

enum DescriptionLevel {
   eDescriptionLevelInitial,
   kNumDescriptionLevels
 };
 
 /// Script interpreter types.
 enum ScriptLanguage {
   eScriptLanguageNone,
   eScriptLanguagePython,
+  eScriptLanguageLua,
   eScriptLanguageDefault = eScriptLanguagePython,
   eScriptLanguageUnknown
 };
 
 /// Register numbering types.
 // See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of
 // these to the lldb internal register numbering scheme (eRegisterKindLLDB).
 enum RegisterKind {

lldb/source/API/SystemInitializerFull.cpp

 //===-- SystemInitializerFull.cpp -------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "SystemInitializerFull.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/Host/Config.h"
 
 #if LLDB_ENABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
+#if LLDB_ENABLE_LUA
+#include "Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.h"
+#endif
+
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Utility/Timer.h"
 
 #include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"

 #if LLDB_ENABLE_PYTHON
   OperatingSystemPython::Initialize();
 #endif
 
 #if LLDB_ENABLE_PYTHON
   ScriptInterpreterPython::Initialize();
 #endif
 
+#if LLDB_ENABLE_LUA
+  ScriptInterpreterLua::Initialize();
+#endif
+
   platform_freebsd::PlatformFreeBSD::Initialize();
   platform_linux::PlatformLinux::Initialize();
   platform_netbsd::PlatformNetBSD::Initialize();
   platform_openbsd::PlatformOpenBSD::Initialize();
   PlatformWindows::Initialize();
   platform_android::PlatformAndroid::Initialize();
   PlatformRemoteiOS::Initialize();
   PlatformMacOSX::Initialize();

lldb/source/Interpreter/OptionArgParser.cpp

 
 lldb::ScriptLanguage OptionArgParser::ToScriptLanguage(
     llvm::StringRef s, lldb::ScriptLanguage fail_value, bool *success_ptr) {
   if (success_ptr)
     *success_ptr = true;
 
   if (s.equals_lower("python"))
     return eScriptLanguagePython;
+  if (s.equals_lower("lua"))
+    return eScriptLanguageLua;
   if (s.equals_lower("default"))
     return eScriptLanguageDefault;
   if (s.equals_lower("none"))
     return eScriptLanguageNone;
 
   if (success_ptr)
     *success_ptr = false;
   return fail_value;

lldb/source/Plugins/ScriptInterpreter/CMakeLists.txt

 add_subdirectory(None)
 if (LLDB_ENABLE_PYTHON)
   add_subdirectory(Python)
 endif()
+
+if (LLDB_ENABLE_LUA)
+  add_subdirectory(Lua)
+endif()

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

+add_lldb_library(lldbPluginScriptInterpreterLua PLUGIN
+  ScriptInterpreterLua.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbInterpreter
+  )
 No newline at end of file

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.h

+//===-- ScriptInterpreterLua.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 liblldb_ScriptInterpreterLua_h_
+#define liblldb_ScriptInterpreterLua_h_
+
+#include "lldb/Interpreter/ScriptInterpreter.h"
+
+namespace lldb_private {
+
+class ScriptInterpreterLua : public ScriptInterpreter {
+public:
+  ScriptInterpreterLua(Debugger &debugger);
+
+  ~ScriptInterpreterLua() override;
+
+  bool ExecuteOneLine(
+      llvm::StringRef command, CommandReturnObject *result,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  void ExecuteInterpreterLoop() override;
+
+  // Static Functions
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  static const char *GetPluginDescriptionStatic();
+
+  // PluginInterface protocol
+  lldb_private::ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_ScriptInterpreterLua_h_

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

+//===-- ScriptInterpreterLua.cpp --------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ScriptInterpreterLua.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StringList.h"
+
+#include "llvm/Support/Threading.h"
+
+#include <mutex>
+
+using namespace lldb;
+using namespace lldb_private;
+
+ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger)
+    : ScriptInterpreter(debugger, eScriptLanguageLua) {}
+
+ScriptInterpreterLua::~ScriptInterpreterLua() {}
+
+bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command,
+                                          CommandReturnObject *,
+                                          const ExecuteScriptOptions &) {
+  m_debugger.GetErrorStream().PutCString(
+      "error: the lua script interpreter is not yet implemented.\n");
+  return false;
+}
+
+void ScriptInterpreterLua::ExecuteInterpreterLoop() {
+  m_debugger.GetErrorStream().PutCString(
+      "error: the lua script interpreter is not yet implemented.\n");
+}
+
+void ScriptInterpreterLua::Initialize() {
+  static llvm::once_flag g_once_flag;
+
+  llvm::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  lldb::eScriptLanguageLua, CreateInstance);
+  });
+}
+
+void ScriptInterpreterLua::Terminate() {}
+
+lldb::ScriptInterpreterSP
+ScriptInterpreterLua::CreateInstance(Debugger &debugger) {
+  return std::make_shared<ScriptInterpreterLua>(debugger);
+}
+
+lldb_private::ConstString ScriptInterpreterLua::GetPluginNameStatic() {
+  static ConstString g_name("script-lua");
+  return g_name;
+}
+
+const char *ScriptInterpreterLua::GetPluginDescriptionStatic() {
+  return "Lua script interpreter";
+}
+
+lldb_private::ConstString ScriptInterpreterLua::GetPluginName() {
+  return GetPluginNameStatic();
+}
+
+uint32_t ScriptInterpreterLua::GetPluginVersion() { return 1; }