[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

28

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...

332

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

28

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

28

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

28

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

49

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

lldb/cmake/modules/LLDBConfig.cmake

 
 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_disable_python OFF)
+set(default_disable_lua OFF)
 set(default_disable_curses OFF)
 set(default_disable_libedit OFF)
 
 if(DEFINED LLVM_ENABLE_LIBEDIT AND NOT LLVM_ENABLE_LIBEDIT)
   set(default_disable_libedit ON)
 endif()
 
 if(CMAKE_SYSTEM_NAME MATCHES "Windows")
   set(default_disable_curses ON)
   set(default_disable_libedit ON)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Android")
   set(default_disable_python ON)
+  set(default_disable_lua ON)
   set(default_disable_curses ON)
   set(default_disable_libedit ON)
 elseif(IOS)
   set(default_disable_python ON)
+  set(default_disable_lua ON)
 endif()
 
 option(LLDB_DISABLE_PYTHON "Disable Python scripting integration." ${default_disable_python})
+option(LLDB_DISABLE_LUA "Disable Lua scripting integration." ${default_disable_lua})
 option(LLDB_DISABLE_CURSES "Disable Curses integration." ${default_disable_curses})
 option(LLDB_DISABLE_LIBEDIT "Disable the use of editline." ${default_disable_libedit})
 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 (LLDB_DISABLE_PYTHON)
   unset(PYTHON_INCLUDE_DIR)
   unset(PYTHON_LIBRARY)
   unset(PYTHON_EXECUTABLE)
   add_definitions( -DLLDB_DISABLE_PYTHON )
 endif()
 
+if (LLDB_DISABLE_LUA)
+  add_definitions( -DLLDB_DISABLE_LUA )
+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

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"
 
 #if !defined(LLDB_DISABLE_PYTHON)
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
+#if !defined(LLDB_DISABLE_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"

 #ifndef LLDB_DISABLE_PYTHON
   OperatingSystemPython::Initialize();
 #endif
 
 #if !defined(LLDB_DISABLE_PYTHON)
   ScriptInterpreterPython::Initialize();
 #endif
 
+#if !defined(LLDB_DISABLE_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 (NOT LLDB_DISABLE_PYTHON)
   add_subdirectory(Python)
 endif()
+
+if (NOT LLDB_DISABLE_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-none");
+  return g_name;
+}
+
+const char *ScriptInterpreterLua::GetPluginDescriptionStatic() {
+  return "Null script interpreter";
+}
+
+lldb_private::ConstString ScriptInterpreterLua::GetPluginName() {
+  return GetPluginNameStatic();
+}
+
+uint32_t ScriptInterpreterLua::GetPluginVersion() { return 1; }