[lldb/lua] Add scripted watchpoints for Lua

[siger-young]

Summary

Add support for Lua scripted watchpoints, with basic tests.

[tammela]

Clang format complained a bit, please fix those.

lldb/test/Shell/ScriptInterpreter/Lua/watchpoint_callback.test

15

More tests cases would be nice

[siger-young]

This comment was removed by siger-young.

[siger-young]

Fix some linting and add extra tests for Lua scripted watchpoints.

[tammela]

I tested locally and it seems fine!

Thanks.

lldb/test/Shell/ScriptInterpreter/Lua/watchpoint_callback.test

23

nit:

I think it makes more readable to change this to CHECK-COUNT-1

[JDevlieghere]

Nice! LGTM.

lldb/bindings/lua/lua-swigsafecast.swig

 
 void
 PushSBClass (lua_State* L, lldb::SBBreakpointLocation* breakpoint_location_sb)
 {
    SWIG_NewPointerObj(L, breakpoint_location_sb, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);
 }
 
 void
+PushSBClass (lua_State* L, lldb::SBWatchpoint* watchpoint_sb)
+{
+   SWIG_NewPointerObj(L, watchpoint_sb, SWIGTYPE_p_lldb__SBWatchpoint, 0);
+}
+
+void
 PushSBClass (lua_State* L, lldb::SBStructuredData* structured_data_sb)
 {
    SWIG_NewPointerObj(L, structured_data_sb, SWIGTYPE_p_lldb__SBStructuredData, 0);
 }

lldb/bindings/lua/lua-wrapper.swig

)
 
    // Boolean return from the callback
    bool stop = lua_toboolean(L, -1);
    lua_pop(L, 1);
 
    return stop;
 }
 
+// This function is called from Lua::CallWatchpointCallback
+SWIGEXPORT llvm::Expected<bool>
+LLDBSwigLuaWatchpointCallbackFunction
+(
+   lua_State *L,
+   lldb::StackFrameSP stop_frame_sp,
+   lldb::WatchpointSP wp_sp
+)
+{
+   lldb::SBFrame sb_frame(stop_frame_sp);
+   lldb::SBWatchpoint sb_wp(wp_sp);
+   int nargs = 2;
+
+   // Push the Lua wrappers
+   PushSBClass(L, &sb_frame);
+   PushSBClass(L, &sb_wp);
+
+   // Call into the Lua callback passing 'sb_frame' and 'sb_wp'.
+   // Expects a boolean return.
+   if (lua_pcall(L, nargs, 1, 0) != LUA_OK) {
+      llvm::Error E = llvm::make_error<llvm::StringError>(
+            llvm::formatv("{0}\n", lua_tostring(L, -1)),
+            llvm::inconvertibleErrorCode());
+      // Pop error message from the stack.
+      lua_pop(L, 1);
+      return std::move(E);
+   }
+
+   // Boolean return from the callback
+   bool stop = lua_toboolean(L, -1);
+   lua_pop(L, 1);
+
+   return stop;
+}
+
 
 %}

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

public:
   ~Lua();
 
   llvm::Error Run(llvm::StringRef buffer);
   llvm::Error RegisterBreakpointCallback(void *baton, const char *body);
   llvm::Expected<bool>
   CallBreakpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp,
                          lldb::BreakpointLocationSP bp_loc_sp,
                          StructuredData::ObjectSP extra_args_sp);
+  llvm::Error RegisterWatchpointCallback(void *baton, const char *body);
+  llvm::Expected<bool> CallWatchpointCallback(void *baton,
+                                              lldb::StackFrameSP stop_frame_sp,
+                                              lldb::WatchpointSP wp_sp);
   llvm::Error LoadModule(llvm::StringRef filename);
   llvm::Error CheckSyntax(llvm::StringRef buffer);
   llvm::Error ChangeIO(FILE *out, FILE *err);
 
 private:
   lua_State *m_lua_state;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Lua_h_

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

 #pragma warning (push)
 #pragma warning (disable : 4190)
 #endif
 
 extern "C" llvm::Expected<bool> LLDBSwigLuaBreakpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp,
     lldb::BreakpointLocationSP bp_loc_sp, StructuredDataImpl *extra_args_impl);
 
+extern "C" llvm::Expected<bool> LLDBSwigLuaWatchpointCallbackFunction(
+    lua_State *L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp);
+
 #if _MSC_VER
 #pragma warning (pop)
 #endif
 
 #pragma clang diagnostic pop
 
 static int lldb_print(lua_State *L) {
   int n = lua_gettop(L);
auto *extra_args_impl = [&]() -> StructuredDataImpl * {
     auto *extra_args_impl = new StructuredDataImpl();
     extra_args_impl->SetObjectSP(extra_args_sp);
     return extra_args_impl;
   }();
   return LLDBSwigLuaBreakpointCallbackFunction(m_lua_state, stop_frame_sp,
                                                bp_loc_sp, extra_args_impl);
 }
 
+llvm::Error Lua::RegisterWatchpointCallback(void *baton, const char *body) {
+  lua_pushlightuserdata(m_lua_state, baton);
+  const char *fmt_str = "return function(frame, wp, ...) {0} end";
+  std::string func_str = llvm::formatv(fmt_str, body).str();
+  if (luaL_dostring(m_lua_state, func_str.c_str()) != LUA_OK) {
+    llvm::Error e = llvm::make_error<llvm::StringError>(
+        llvm::formatv("{0}", lua_tostring(m_lua_state, -1)),
+        llvm::inconvertibleErrorCode());
+    // Pop error message from the stack.
+    lua_pop(m_lua_state, 2);
+    return e;
+  }
+  lua_settable(m_lua_state, LUA_REGISTRYINDEX);
+  return llvm::Error::success();
+}
+
+llvm::Expected<bool>
+Lua::CallWatchpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp,
+                            lldb::WatchpointSP wp_sp) {
+
+  lua_pushlightuserdata(m_lua_state, baton);
+  lua_gettable(m_lua_state, LUA_REGISTRYINDEX);
+  return LLDBSwigLuaWatchpointCallbackFunction(m_lua_state, stop_frame_sp,
+                                               wp_sp);
+}
+
 llvm::Error Lua::CheckSyntax(llvm::StringRef buffer) {
   int error =
       luaL_loadbuffer(m_lua_state, buffer.data(), buffer.size(), "buffer");
   if (error == LUA_OK) {
     // Pop buffer
     lua_pop(m_lua_state, 1);
     return llvm::Error::success();
   }

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 <vector>
 
+#include "lldb/Breakpoint/WatchpointOptions.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 
 namespace lldb_private {
 class Lua;
 class ScriptInterpreterLua : public ScriptInterpreter {
public:
 
   static const char *GetPluginDescriptionStatic();
 
   static bool BreakpointCallbackFunction(void *baton,
                                          StoppointCallbackContext *context,
                                          lldb::user_id_t break_id,
                                          lldb::user_id_t break_loc_id);
 
+  static bool WatchpointCallbackFunction(void *baton,
+                                         StoppointCallbackContext *context,
+                                         lldb::user_id_t watch_id);
+
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   Lua &GetLua();
 
   llvm::Error EnterSession(lldb::user_id_t debugger_id);
   llvm::Error LeaveSession();
 
   void CollectDataForBreakpointCommandCallback(
       std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
       CommandReturnObject &result) override;
 
+  void
+  CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                          CommandReturnObject &result) override;
+
   Status SetBreakpointCommandCallback(BreakpointOptions &bp_options,
                                       const char *command_body_text) override;
 
+  void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                    const char *command_body_text) override;
+
   Status SetBreakpointCommandCallbackFunction(
       BreakpointOptions &bp_options, const char *function_name,
       StructuredData::ObjectSP extra_args_sp) override;
 
 private:
   std::unique_ptr<Lua> m_lua;
   bool m_session_is_active = false;
 
   Status RegisterBreakpointCallback(BreakpointOptions &bp_options,
                                     const char *command_body_text,
                                     StructuredData::ObjectSP extra_args_sp);
+
+  Status RegisterWatchpointCallback(WatchpointOptions *wp_options,
+                                    const char *command_body_text,
+                                    StructuredData::ObjectSP extra_args_sp);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ScriptInterpreterLua_h_

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

public:
   ~IOHandlerLuaInterpreter() override {
     llvm::cantFail(m_script_interpreter.LeaveSession());
   }
 
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
     const char *instructions = nullptr;
     switch (m_active_io_handler) {
     case eIOHandlerNone:
+      break;
     case eIOHandlerWatchpoint:
+      instructions = "Enter your Lua command(s). Type 'quit' to end.\n"
+                     "The commands are compiled as the body of the following "
+                     "Lua function\n"
+                     "function (frame, wp) end\n";
+      SetPrompt(llvm::StringRef("..> "));
       break;
     case eIOHandlerBreakpoint:
       instructions = "Enter your Lua command(s). Type 'quit' to end.\n"
                      "The commands are compiled as the body of the following "
                      "Lua function\n"
                      "function (frame, bp_loc, ...) end\n";
       SetPrompt(llvm::StringRef("..> "));
       break;
     }
     if (instructions == nullptr)
       return;
     if (interactive)
       *io_handler.GetOutputStreamFileSP() << instructions;
   }
 
   bool IOHandlerIsInputComplete(IOHandler &io_handler,
                                 StringList &lines) override {
     size_t last = lines.GetSize() - 1;
     if (IsQuitCommand(lines.GetStringAtIndex(last))) {
-      if (m_active_io_handler == eIOHandlerBreakpoint)
+      if (m_active_io_handler == eIOHandlerBreakpoint ||
+          m_active_io_handler == eIOHandlerWatchpoint)
         lines.DeleteStringAtIndex(last);
       return true;
     }
     StreamString str;
     lines.Join("\n", str);
     if (llvm::Error E =
             m_script_interpreter.GetLua().CheckSyntax(str.GetString())) {
       std::string error_str = toString(std::move(E));
       // Lua always errors out to incomplete code with '<eof>'
       return error_str.find("<eof>") == std::string::npos;
     }
-    // The breakpoint handler only exits with a explicit 'quit'
-    return m_active_io_handler != eIOHandlerBreakpoint;
+    // The breakpoint and watchpoint handler only exits with a explicit 'quit'
+    return m_active_io_handler != eIOHandlerBreakpoint &&
+           m_active_io_handler != eIOHandlerWatchpoint;
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
     switch (m_active_io_handler) {
     case eIOHandlerBreakpoint: {
       auto *bp_options_vec =
           static_cast<std::vector<std::reference_wrapper<BreakpointOptions>> *>(
               io_handler.GetUserData());
       for (BreakpointOptions &bp_options : *bp_options_vec) {
         Status error = m_script_interpreter.SetBreakpointCommandCallback(
             bp_options, data.c_str());
         if (error.Fail())
           *io_handler.GetErrorStreamFileSP() << error.AsCString() << '\n';
       }
       io_handler.SetIsDone(true);
     } break;
-    case eIOHandlerWatchpoint:
+    case eIOHandlerWatchpoint: {
+      auto *wp_options =
+          static_cast<WatchpointOptions *>(io_handler.GetUserData());
+      m_script_interpreter.SetWatchpointCommandCallback(wp_options,
+                                                        data.c_str());
       io_handler.SetIsDone(true);
-      break;
+    } break;
     case eIOHandlerNone:
       if (IsQuitCommand(data)) {
         io_handler.SetIsDone(true);
         return;
       }
       if (llvm::Error error = m_script_interpreter.GetLua().Run(data))
         *io_handler.GetErrorStreamFileSP() << toString(std::move(error));
       break;
bool ScriptInterpreterLua::BreakpointCallbackFunction(
   if (llvm::Error E = BoolOrErr.takeError()) {
     debugger.GetErrorStream() << toString(std::move(E));
     return true;
   }
 
   return *BoolOrErr;
 }
 
+bool ScriptInterpreterLua::WatchpointCallbackFunction(
+    void *baton, StoppointCallbackContext *context, user_id_t watch_id) {
+  assert(context);
+
+  ExecutionContext exe_ctx(context->exe_ctx_ref);
+  Target *target = exe_ctx.GetTargetPtr();
+  if (target == nullptr)
+    return true;
+
+  StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
+  WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
+
+  Debugger &debugger = target->GetDebugger();
+  ScriptInterpreterLua *lua_interpreter = static_cast<ScriptInterpreterLua *>(
+      debugger.GetScriptInterpreter(true, eScriptLanguageLua));
+  Lua &lua = lua_interpreter->GetLua();
+
+  llvm::Expected<bool> BoolOrErr =
+      lua.CallWatchpointCallback(baton, stop_frame_sp, wp_sp);
+  if (llvm::Error E = BoolOrErr.takeError()) {
+    debugger.GetErrorStream() << toString(std::move(E));
+    return true;
+  }
+
+  return *BoolOrErr;
+}
+
 void ScriptInterpreterLua::CollectDataForBreakpointCommandCallback(
     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
     CommandReturnObject &result) {
   IOHandlerSP io_handler_sp(
       new IOHandlerLuaInterpreter(m_debugger, *this, eIOHandlerBreakpoint));
   io_handler_sp->SetUserData(&bp_options_vec);
   m_debugger.RunIOHandlerAsync(io_handler_sp);
 }
 
+void ScriptInterpreterLua::CollectDataForWatchpointCommandCallback(
+    WatchpointOptions *wp_options, CommandReturnObject &result) {
+  IOHandlerSP io_handler_sp(
+      new IOHandlerLuaInterpreter(m_debugger, *this, eIOHandlerWatchpoint));
+  io_handler_sp->SetUserData(wp_options);
+  m_debugger.RunIOHandlerAsync(io_handler_sp);
+}
+
 Status ScriptInterpreterLua::SetBreakpointCommandCallbackFunction(
     BreakpointOptions &bp_options, const char *function_name,
     StructuredData::ObjectSP extra_args_sp) {
   const char *fmt_str = "return {0}(frame, bp_loc, ...)";
   std::string oneliner = llvm::formatv(fmt_str, function_name).str();
   return RegisterBreakpointCallback(bp_options, oneliner.c_str(),
                                     extra_args_sp);
 }
if (error.Fail())
     return error;
   auto baton_sp =
       std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
   bp_options.SetCallback(ScriptInterpreterLua::BreakpointCallbackFunction,
                          baton_sp);
   return error;
 }
 
+void ScriptInterpreterLua::SetWatchpointCommandCallback(
+    WatchpointOptions *wp_options, const char *command_body_text) {
+  RegisterWatchpointCallback(wp_options, command_body_text, {});
+}
+
+Status ScriptInterpreterLua::RegisterWatchpointCallback(
+    WatchpointOptions *wp_options, const char *command_body_text,
+    StructuredData::ObjectSP extra_args_sp) {
+  Status error;
+  auto data_up = std::make_unique<WatchpointOptions::CommandData>();
+  error = m_lua->RegisterWatchpointCallback(data_up.get(), command_body_text);
+  if (error.Fail())
+    return error;
+  auto baton_sp =
+      std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
+  wp_options->SetCallback(ScriptInterpreterLua::WatchpointCallbackFunction,
+                          baton_sp);
+  return error;
+}
+
 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;

lldb/test/Shell/ScriptInterpreter/Lua/watchpoint_callback.test

 # REQUIRES: lua
 # XFAIL: system-netbsd
-# RUN: echo "int main() { return 0; }" | %clang_host -x c - -o %t
+# RUN: echo "int main() { int val = 1; val++; return 0; }" | %clang_host -x c - -g -o %t
 # RUN: %lldb -s %s --script-language lua %t 2>&1 | FileCheck %s
 b main
 r
-watchpoint set expr 0x0
+watchpoint set variable val
 watchpoint command add -s lua
-# CHECK: error: This script interpreter does not support watchpoint callbacks
+print("val=" .. tostring(frame:FindVariable("val"):GetValue()))
+quit
+c
+# CHECK: val=1
+# CHECK: val=2
+# CHECK: Process {{[0-9]+}} exited
+r
+watchpoint set variable val
+watchpoint modify 1 -c "(val == 1)"
+watchpoint command add -s lua
+print("conditional watchpoint")
+wp:SetEnabled(false)
+quit
+c
+# CHECK-COUNT-1: conditional watchpoint
+# CHECK-NOT: conditional watchpoint
+# CHECK: Process {{[0-9]+}} exited
+r
+watchpoint set expr 0x00
+watchpoint command add -s lua
+print("never triggers")
+quit
+c
+# CHECK-NOT: never triggers
+# CHECK: Process {{[0-9]+}} exited

lldb/unittests/ScriptInterpreter/Lua/LuaTests.cpp

 #endif
 
 extern "C" llvm::Expected<bool> LLDBSwigLuaBreakpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp,
     lldb::BreakpointLocationSP bp_loc_sp, StructuredDataImpl *extra_args_impl) {
   return false;
 }
 
+extern "C" llvm::Expected<bool> LLDBSwigLuaWatchpointCallbackFunction(
+    lua_State *L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp) {
+  return false;
+}
+
 #if _MSC_VER
 #pragma warning (pop)
 #endif
 
 #pragma clang diagnostic pop
 
 TEST(LuaTest, RunValid) {
   Lua lua;