1 //===-- ScriptInterpreterLua.cpp ------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "ScriptInterpreterLua.h"
10 #include "Lua.h"
11 #include "lldb/Breakpoint/StoppointCallbackContext.h"
12 #include "lldb/Core/Debugger.h"
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Core/StreamFile.h"
15 #include "lldb/Interpreter/CommandReturnObject.h"
16 #include "lldb/Target/ExecutionContext.h"
17 #include "lldb/Utility/Stream.h"
18 #include "lldb/Utility/StringList.h"
19 #include "lldb/Utility/Timer.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/FormatAdapters.h"
22 #include <memory>
23 #include <vector>
24 
25 using namespace lldb;
26 using namespace lldb_private;
27 
28 LLDB_PLUGIN_DEFINE(ScriptInterpreterLua)
29 
30 enum ActiveIOHandler {
31   eIOHandlerNone,
32   eIOHandlerBreakpoint,
33   eIOHandlerWatchpoint
34 };
35 
36 class IOHandlerLuaInterpreter : public IOHandlerDelegate,
37                                 public IOHandlerEditline {
38 public:
39   IOHandlerLuaInterpreter(Debugger &debugger,
40                           ScriptInterpreterLua &script_interpreter,
41                           ActiveIOHandler active_io_handler = eIOHandlerNone)
42       : IOHandlerEditline(debugger, IOHandler::Type::LuaInterpreter, "lua",
43                           llvm::StringRef(">>> "), llvm::StringRef("..> "),
44                           true, debugger.GetUseColor(), 0, *this),
45         m_script_interpreter(script_interpreter),
46         m_active_io_handler(active_io_handler) {
47     llvm::cantFail(m_script_interpreter.GetLua().ChangeIO(
48         debugger.GetOutputFile().GetStream(),
49         debugger.GetErrorFile().GetStream()));
50     llvm::cantFail(m_script_interpreter.EnterSession(debugger.GetID()));
51   }
52 
53   ~IOHandlerLuaInterpreter() override {
54     llvm::cantFail(m_script_interpreter.LeaveSession());
55   }
56 
57   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
58     const char *instructions = nullptr;
59     switch (m_active_io_handler) {
60     case eIOHandlerNone:
61       break;
62     case eIOHandlerWatchpoint:
63       instructions = "Enter your Lua command(s). Type 'quit' to end.\n"
64                      "The commands are compiled as the body of the following "
65                      "Lua function\n"
66                      "function (frame, wp) end\n";
67       SetPrompt(llvm::StringRef("..> "));
68       break;
69     case eIOHandlerBreakpoint:
70       instructions = "Enter your Lua command(s). Type 'quit' to end.\n"
71                      "The commands are compiled as the body of the following "
72                      "Lua function\n"
73                      "function (frame, bp_loc, ...) end\n";
74       SetPrompt(llvm::StringRef("..> "));
75       break;
76     }
77     if (instructions == nullptr)
78       return;
79     if (interactive)
80       *io_handler.GetOutputStreamFileSP() << instructions;
81   }
82 
83   bool IOHandlerIsInputComplete(IOHandler &io_handler,
84                                 StringList &lines) override {
85     size_t last = lines.GetSize() - 1;
86     if (IsQuitCommand(lines.GetStringAtIndex(last))) {
87       if (m_active_io_handler == eIOHandlerBreakpoint ||
88           m_active_io_handler == eIOHandlerWatchpoint)
89         lines.DeleteStringAtIndex(last);
90       return true;
91     }
92     StreamString str;
93     lines.Join("\n", str);
94     if (llvm::Error E =
95             m_script_interpreter.GetLua().CheckSyntax(str.GetString())) {
96       std::string error_str = toString(std::move(E));
97       // Lua always errors out to incomplete code with '<eof>'
98       return error_str.find("<eof>") == std::string::npos;
99     }
100     // The breakpoint and watchpoint handler only exits with a explicit 'quit'
101     return m_active_io_handler != eIOHandlerBreakpoint &&
102            m_active_io_handler != eIOHandlerWatchpoint;
103   }
104 
105   void IOHandlerInputComplete(IOHandler &io_handler,
106                               std::string &data) override {
107     switch (m_active_io_handler) {
108     case eIOHandlerBreakpoint: {
109       auto *bp_options_vec =
110           static_cast<std::vector<std::reference_wrapper<BreakpointOptions>> *>(
111               io_handler.GetUserData());
112       for (BreakpointOptions &bp_options : *bp_options_vec) {
113         Status error = m_script_interpreter.SetBreakpointCommandCallback(
114             bp_options, data.c_str());
115         if (error.Fail())
116           *io_handler.GetErrorStreamFileSP() << error.AsCString() << '\n';
117       }
118       io_handler.SetIsDone(true);
119     } break;
120     case eIOHandlerWatchpoint: {
121       auto *wp_options =
122           static_cast<WatchpointOptions *>(io_handler.GetUserData());
123       m_script_interpreter.SetWatchpointCommandCallback(wp_options,
124                                                         data.c_str());
125       io_handler.SetIsDone(true);
126     } break;
127     case eIOHandlerNone:
128       if (IsQuitCommand(data)) {
129         io_handler.SetIsDone(true);
130         return;
131       }
132       if (llvm::Error error = m_script_interpreter.GetLua().Run(data))
133         *io_handler.GetErrorStreamFileSP() << toString(std::move(error));
134       break;
135     }
136   }
137 
138 private:
139   ScriptInterpreterLua &m_script_interpreter;
140   ActiveIOHandler m_active_io_handler;
141 
142   bool IsQuitCommand(llvm::StringRef cmd) { return cmd.rtrim() == "quit"; }
143 };
144 
145 ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger)
146     : ScriptInterpreter(debugger, eScriptLanguageLua),
147       m_lua(std::make_unique<Lua>()) {}
148 
149 ScriptInterpreterLua::~ScriptInterpreterLua() = default;
150 
151 StructuredData::DictionarySP ScriptInterpreterLua::GetInterpreterInfo() {
152   auto info = std::make_shared<StructuredData::Dictionary>();
153   info->AddStringItem("language", "lua");
154   return info;
155 }
156 
157 bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command,
158                                           CommandReturnObject *result,
159                                           const ExecuteScriptOptions &options) {
160   if (command.empty()) {
161     if (result)
162       result->AppendError("empty command passed to lua\n");
163     return false;
164   }
165 
166   llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
167       io_redirect_or_error = ScriptInterpreterIORedirect::Create(
168           options.GetEnableIO(), m_debugger, result);
169   if (!io_redirect_or_error) {
170     if (result)
171       result->AppendErrorWithFormatv(
172           "failed to redirect I/O: {0}\n",
173           llvm::fmt_consume(io_redirect_or_error.takeError()));
174     else
175       llvm::consumeError(io_redirect_or_error.takeError());
176     return false;
177   }
178 
179   ScriptInterpreterIORedirect &io_redirect = **io_redirect_or_error;
180 
181   if (llvm::Error e =
182           m_lua->ChangeIO(io_redirect.GetOutputFile()->GetStream(),
183                           io_redirect.GetErrorFile()->GetStream())) {
184     result->AppendErrorWithFormatv("lua failed to redirect I/O: {0}\n",
185                                    llvm::toString(std::move(e)));
186     return false;
187   }
188 
189   if (llvm::Error e = m_lua->Run(command)) {
190     result->AppendErrorWithFormatv(
191         "lua failed attempting to evaluate '{0}': {1}\n", command,
192         llvm::toString(std::move(e)));
193     return false;
194   }
195 
196   io_redirect.Flush();
197   return true;
198 }
199 
200 void ScriptInterpreterLua::ExecuteInterpreterLoop() {
201   LLDB_SCOPED_TIMER();
202 
203   // At the moment, the only time the debugger does not have an input file
204   // handle is when this is called directly from lua, in which case it is
205   // both dangerous and unnecessary (not to mention confusing) to try to embed
206   // a running interpreter loop inside the already running lua interpreter
207   // loop, so we won't do it.
208   if (!m_debugger.GetInputFile().IsValid())
209     return;
210 
211   IOHandlerSP io_handler_sp(new IOHandlerLuaInterpreter(m_debugger, *this));
212   m_debugger.RunIOHandlerAsync(io_handler_sp);
213 }
214 
215 bool ScriptInterpreterLua::LoadScriptingModule(
216     const char *filename, const LoadScriptOptions &options,
217     lldb_private::Status &error, StructuredData::ObjectSP *module_sp,
218     FileSpec extra_search_dir) {
219 
220   if (llvm::Error e = m_lua->LoadModule(filename)) {
221     error.SetErrorStringWithFormatv("lua failed to import '{0}': {1}\n",
222                                     filename, llvm::toString(std::move(e)));
223     return false;
224   }
225   return true;
226 }
227 
228 void ScriptInterpreterLua::Initialize() {
229   static llvm::once_flag g_once_flag;
230 
231   llvm::call_once(g_once_flag, []() {
232     PluginManager::RegisterPlugin(GetPluginNameStatic(),
233                                   GetPluginDescriptionStatic(),
234                                   lldb::eScriptLanguageLua, CreateInstance);
235   });
236 }
237 
238 void ScriptInterpreterLua::Terminate() {}
239 
240 llvm::Error ScriptInterpreterLua::EnterSession(user_id_t debugger_id) {
241   if (m_session_is_active)
242     return llvm::Error::success();
243 
244   const char *fmt_str =
245       "lldb.debugger = lldb.SBDebugger.FindDebuggerWithID({0}); "
246       "lldb.target = lldb.debugger:GetSelectedTarget(); "
247       "lldb.process = lldb.target:GetProcess(); "
248       "lldb.thread = lldb.process:GetSelectedThread(); "
249       "lldb.frame = lldb.thread:GetSelectedFrame()";
250   return m_lua->Run(llvm::formatv(fmt_str, debugger_id).str());
251 }
252 
253 llvm::Error ScriptInterpreterLua::LeaveSession() {
254   if (!m_session_is_active)
255     return llvm::Error::success();
256 
257   m_session_is_active = false;
258 
259   llvm::StringRef str = "lldb.debugger = nil; "
260                         "lldb.target = nil; "
261                         "lldb.process = nil; "
262                         "lldb.thread = nil; "
263                         "lldb.frame = nil";
264   return m_lua->Run(str);
265 }
266 
267 bool ScriptInterpreterLua::BreakpointCallbackFunction(
268     void *baton, StoppointCallbackContext *context, user_id_t break_id,
269     user_id_t break_loc_id) {
270   assert(context);
271 
272   ExecutionContext exe_ctx(context->exe_ctx_ref);
273   Target *target = exe_ctx.GetTargetPtr();
274   if (target == nullptr)
275     return true;
276 
277   StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
278   BreakpointSP breakpoint_sp = target->GetBreakpointByID(break_id);
279   BreakpointLocationSP bp_loc_sp(breakpoint_sp->FindLocationByID(break_loc_id));
280 
281   Debugger &debugger = target->GetDebugger();
282   ScriptInterpreterLua *lua_interpreter = static_cast<ScriptInterpreterLua *>(
283       debugger.GetScriptInterpreter(true, eScriptLanguageLua));
284   Lua &lua = lua_interpreter->GetLua();
285 
286   CommandDataLua *bp_option_data = static_cast<CommandDataLua *>(baton);
287   llvm::Expected<bool> BoolOrErr = lua.CallBreakpointCallback(
288       baton, stop_frame_sp, bp_loc_sp, bp_option_data->m_extra_args_sp);
289   if (llvm::Error E = BoolOrErr.takeError()) {
290     debugger.GetErrorStream() << toString(std::move(E));
291     return true;
292   }
293 
294   return *BoolOrErr;
295 }
296 
297 bool ScriptInterpreterLua::WatchpointCallbackFunction(
298     void *baton, StoppointCallbackContext *context, user_id_t watch_id) {
299   assert(context);
300 
301   ExecutionContext exe_ctx(context->exe_ctx_ref);
302   Target *target = exe_ctx.GetTargetPtr();
303   if (target == nullptr)
304     return true;
305 
306   StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
307   WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
308 
309   Debugger &debugger = target->GetDebugger();
310   ScriptInterpreterLua *lua_interpreter = static_cast<ScriptInterpreterLua *>(
311       debugger.GetScriptInterpreter(true, eScriptLanguageLua));
312   Lua &lua = lua_interpreter->GetLua();
313 
314   llvm::Expected<bool> BoolOrErr =
315       lua.CallWatchpointCallback(baton, stop_frame_sp, wp_sp);
316   if (llvm::Error E = BoolOrErr.takeError()) {
317     debugger.GetErrorStream() << toString(std::move(E));
318     return true;
319   }
320 
321   return *BoolOrErr;
322 }
323 
324 void ScriptInterpreterLua::CollectDataForBreakpointCommandCallback(
325     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
326     CommandReturnObject &result) {
327   IOHandlerSP io_handler_sp(
328       new IOHandlerLuaInterpreter(m_debugger, *this, eIOHandlerBreakpoint));
329   io_handler_sp->SetUserData(&bp_options_vec);
330   m_debugger.RunIOHandlerAsync(io_handler_sp);
331 }
332 
333 void ScriptInterpreterLua::CollectDataForWatchpointCommandCallback(
334     WatchpointOptions *wp_options, CommandReturnObject &result) {
335   IOHandlerSP io_handler_sp(
336       new IOHandlerLuaInterpreter(m_debugger, *this, eIOHandlerWatchpoint));
337   io_handler_sp->SetUserData(wp_options);
338   m_debugger.RunIOHandlerAsync(io_handler_sp);
339 }
340 
341 Status ScriptInterpreterLua::SetBreakpointCommandCallbackFunction(
342     BreakpointOptions &bp_options, const char *function_name,
343     StructuredData::ObjectSP extra_args_sp) {
344   const char *fmt_str = "return {0}(frame, bp_loc, ...)";
345   std::string oneliner = llvm::formatv(fmt_str, function_name).str();
346   return RegisterBreakpointCallback(bp_options, oneliner.c_str(),
347                                     extra_args_sp);
348 }
349 
350 Status ScriptInterpreterLua::SetBreakpointCommandCallback(
351     BreakpointOptions &bp_options, const char *command_body_text) {
352   return RegisterBreakpointCallback(bp_options, command_body_text, {});
353 }
354 
355 Status ScriptInterpreterLua::RegisterBreakpointCallback(
356     BreakpointOptions &bp_options, const char *command_body_text,
357     StructuredData::ObjectSP extra_args_sp) {
358   Status error;
359   auto data_up = std::make_unique<CommandDataLua>(extra_args_sp);
360   error = m_lua->RegisterBreakpointCallback(data_up.get(), command_body_text);
361   if (error.Fail())
362     return error;
363   auto baton_sp =
364       std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
365   bp_options.SetCallback(ScriptInterpreterLua::BreakpointCallbackFunction,
366                          baton_sp);
367   return error;
368 }
369 
370 void ScriptInterpreterLua::SetWatchpointCommandCallback(
371     WatchpointOptions *wp_options, const char *command_body_text) {
372   RegisterWatchpointCallback(wp_options, command_body_text, {});
373 }
374 
375 Status ScriptInterpreterLua::RegisterWatchpointCallback(
376     WatchpointOptions *wp_options, const char *command_body_text,
377     StructuredData::ObjectSP extra_args_sp) {
378   Status error;
379   auto data_up = std::make_unique<WatchpointOptions::CommandData>();
380   error = m_lua->RegisterWatchpointCallback(data_up.get(), command_body_text);
381   if (error.Fail())
382     return error;
383   auto baton_sp =
384       std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
385   wp_options->SetCallback(ScriptInterpreterLua::WatchpointCallbackFunction,
386                           baton_sp);
387   return error;
388 }
389 
390 lldb::ScriptInterpreterSP
391 ScriptInterpreterLua::CreateInstance(Debugger &debugger) {
392   return std::make_shared<ScriptInterpreterLua>(debugger);
393 }
394 
395 llvm::StringRef ScriptInterpreterLua::GetPluginDescriptionStatic() {
396   return "Lua script interpreter";
397 }
398 
399 Lua &ScriptInterpreterLua::GetLua() { return *m_lua; }
400