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                           ">>> ", "..> ", true, debugger.GetUseColor(), 0,
44                           *this, nullptr),
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   FileSystem::Instance().Collect(filename);
221   if (llvm::Error e = m_lua->LoadModule(filename)) {
222     error.SetErrorStringWithFormatv("lua failed to import '{0}': {1}\n",
223                                     filename, llvm::toString(std::move(e)));
224     return false;
225   }
226   return true;
227 }
228 
229 void ScriptInterpreterLua::Initialize() {
230   static llvm::once_flag g_once_flag;
231 
232   llvm::call_once(g_once_flag, []() {
233     PluginManager::RegisterPlugin(GetPluginNameStatic(),
234                                   GetPluginDescriptionStatic(),
235                                   lldb::eScriptLanguageLua, CreateInstance);
236   });
237 }
238 
239 void ScriptInterpreterLua::Terminate() {}
240 
241 llvm::Error ScriptInterpreterLua::EnterSession(user_id_t debugger_id) {
242   if (m_session_is_active)
243     return llvm::Error::success();
244 
245   const char *fmt_str =
246       "lldb.debugger = lldb.SBDebugger.FindDebuggerWithID({0}); "
247       "lldb.target = lldb.debugger:GetSelectedTarget(); "
248       "lldb.process = lldb.target:GetProcess(); "
249       "lldb.thread = lldb.process:GetSelectedThread(); "
250       "lldb.frame = lldb.thread:GetSelectedFrame()";
251   return m_lua->Run(llvm::formatv(fmt_str, debugger_id).str());
252 }
253 
254 llvm::Error ScriptInterpreterLua::LeaveSession() {
255   if (!m_session_is_active)
256     return llvm::Error::success();
257 
258   m_session_is_active = false;
259 
260   llvm::StringRef str = "lldb.debugger = nil; "
261                         "lldb.target = nil; "
262                         "lldb.process = nil; "
263                         "lldb.thread = nil; "
264                         "lldb.frame = nil";
265   return m_lua->Run(str);
266 }
267 
268 bool ScriptInterpreterLua::BreakpointCallbackFunction(
269     void *baton, StoppointCallbackContext *context, user_id_t break_id,
270     user_id_t break_loc_id) {
271   assert(context);
272 
273   ExecutionContext exe_ctx(context->exe_ctx_ref);
274   Target *target = exe_ctx.GetTargetPtr();
275   if (target == nullptr)
276     return true;
277 
278   StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
279   BreakpointSP breakpoint_sp = target->GetBreakpointByID(break_id);
280   BreakpointLocationSP bp_loc_sp(breakpoint_sp->FindLocationByID(break_loc_id));
281 
282   Debugger &debugger = target->GetDebugger();
283   ScriptInterpreterLua *lua_interpreter = static_cast<ScriptInterpreterLua *>(
284       debugger.GetScriptInterpreter(true, eScriptLanguageLua));
285   Lua &lua = lua_interpreter->GetLua();
286 
287   CommandDataLua *bp_option_data = static_cast<CommandDataLua *>(baton);
288   llvm::Expected<bool> BoolOrErr = lua.CallBreakpointCallback(
289       baton, stop_frame_sp, bp_loc_sp, bp_option_data->m_extra_args_sp);
290   if (llvm::Error E = BoolOrErr.takeError()) {
291     debugger.GetErrorStream() << toString(std::move(E));
292     return true;
293   }
294 
295   return *BoolOrErr;
296 }
297 
298 bool ScriptInterpreterLua::WatchpointCallbackFunction(
299     void *baton, StoppointCallbackContext *context, user_id_t watch_id) {
300   assert(context);
301 
302   ExecutionContext exe_ctx(context->exe_ctx_ref);
303   Target *target = exe_ctx.GetTargetPtr();
304   if (target == nullptr)
305     return true;
306 
307   StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
308   WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
309 
310   Debugger &debugger = target->GetDebugger();
311   ScriptInterpreterLua *lua_interpreter = static_cast<ScriptInterpreterLua *>(
312       debugger.GetScriptInterpreter(true, eScriptLanguageLua));
313   Lua &lua = lua_interpreter->GetLua();
314 
315   llvm::Expected<bool> BoolOrErr =
316       lua.CallWatchpointCallback(baton, stop_frame_sp, wp_sp);
317   if (llvm::Error E = BoolOrErr.takeError()) {
318     debugger.GetErrorStream() << toString(std::move(E));
319     return true;
320   }
321 
322   return *BoolOrErr;
323 }
324 
325 void ScriptInterpreterLua::CollectDataForBreakpointCommandCallback(
326     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
327     CommandReturnObject &result) {
328   IOHandlerSP io_handler_sp(
329       new IOHandlerLuaInterpreter(m_debugger, *this, eIOHandlerBreakpoint));
330   io_handler_sp->SetUserData(&bp_options_vec);
331   m_debugger.RunIOHandlerAsync(io_handler_sp);
332 }
333 
334 void ScriptInterpreterLua::CollectDataForWatchpointCommandCallback(
335     WatchpointOptions *wp_options, CommandReturnObject &result) {
336   IOHandlerSP io_handler_sp(
337       new IOHandlerLuaInterpreter(m_debugger, *this, eIOHandlerWatchpoint));
338   io_handler_sp->SetUserData(wp_options);
339   m_debugger.RunIOHandlerAsync(io_handler_sp);
340 }
341 
342 Status ScriptInterpreterLua::SetBreakpointCommandCallbackFunction(
343     BreakpointOptions &bp_options, const char *function_name,
344     StructuredData::ObjectSP extra_args_sp) {
345   const char *fmt_str = "return {0}(frame, bp_loc, ...)";
346   std::string oneliner = llvm::formatv(fmt_str, function_name).str();
347   return RegisterBreakpointCallback(bp_options, oneliner.c_str(),
348                                     extra_args_sp);
349 }
350 
351 Status ScriptInterpreterLua::SetBreakpointCommandCallback(
352     BreakpointOptions &bp_options, const char *command_body_text) {
353   return RegisterBreakpointCallback(bp_options, command_body_text, {});
354 }
355 
356 Status ScriptInterpreterLua::RegisterBreakpointCallback(
357     BreakpointOptions &bp_options, const char *command_body_text,
358     StructuredData::ObjectSP extra_args_sp) {
359   Status error;
360   auto data_up = std::make_unique<CommandDataLua>(extra_args_sp);
361   error = m_lua->RegisterBreakpointCallback(data_up.get(), command_body_text);
362   if (error.Fail())
363     return error;
364   auto baton_sp =
365       std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
366   bp_options.SetCallback(ScriptInterpreterLua::BreakpointCallbackFunction,
367                          baton_sp);
368   return error;
369 }
370 
371 void ScriptInterpreterLua::SetWatchpointCommandCallback(
372     WatchpointOptions *wp_options, const char *command_body_text) {
373   RegisterWatchpointCallback(wp_options, command_body_text, {});
374 }
375 
376 Status ScriptInterpreterLua::RegisterWatchpointCallback(
377     WatchpointOptions *wp_options, const char *command_body_text,
378     StructuredData::ObjectSP extra_args_sp) {
379   Status error;
380   auto data_up = std::make_unique<WatchpointOptions::CommandData>();
381   error = m_lua->RegisterWatchpointCallback(data_up.get(), command_body_text);
382   if (error.Fail())
383     return error;
384   auto baton_sp =
385       std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
386   wp_options->SetCallback(ScriptInterpreterLua::WatchpointCallbackFunction,
387                           baton_sp);
388   return error;
389 }
390 
391 lldb::ScriptInterpreterSP
392 ScriptInterpreterLua::CreateInstance(Debugger &debugger) {
393   return std::make_shared<ScriptInterpreterLua>(debugger);
394 }
395 
396 llvm::StringRef ScriptInterpreterLua::GetPluginDescriptionStatic() {
397   return "Lua script interpreter";
398 }
399 
400 Lua &ScriptInterpreterLua::GetLua() { return *m_lua; }
401