LLDB mainline
ScriptInterpreterLua.cpp
Go to the documentation of this file.
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
10#include "Lua.h"
12#include "lldb/Core/Debugger.h"
17#include "lldb/Utility/Stream.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
25using namespace lldb;
26using namespace lldb_private;
27
29
34};
35
37 public IOHandlerEditline {
38public:
40 ScriptInterpreterLua &script_interpreter,
41 ActiveIOHandler active_io_handler = eIOHandlerNone)
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
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;
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;
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
84 StringList &lines) override {
85 size_t last = lines.GetSize() - 1;
86 if (IsQuitCommand(lines.GetStringAtIndex(last))) {
89 lines.DeleteStringAtIndex(last);
90 return true;
91 }
92 StreamString str;
93 lines.Join("\n", str);
94 if (llvm::Error E =
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'
103 }
104
106 std::string &data) override {
107 switch (m_active_io_handler) {
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) {
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;
121 auto *wp_options =
122 static_cast<WatchpointOptions *>(io_handler.GetUserData());
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
138private:
141
142 bool IsQuitCommand(llvm::StringRef cmd) { return cmd.rtrim() == "quit"; }
143};
144
147 m_lua(std::make_unique<Lua>()) {}
148
150
152 auto info = std::make_shared<StructuredData::Dictionary>();
153 info->AddStringItem("language", "lua");
154 return info;
155}
156
157bool 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)
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)) {
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
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.
209 return;
210
211 IOHandlerSP io_handler_sp(new IOHandlerLuaInterpreter(m_debugger, *this));
212 m_debugger.RunIOHandlerAsync(io_handler_sp);
213}
214
216 const char *filename, const LoadScriptOptions &options,
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
229 static llvm::once_flag g_once_flag;
230
231 llvm::call_once(g_once_flag, []() {
235 });
236}
237
239
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
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
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 *>(
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
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 *>(
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
325 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
326 CommandReturnObject &result) {
327 IOHandlerSP io_handler_sp(
329 io_handler_sp->SetUserData(&bp_options_vec);
330 m_debugger.RunIOHandlerAsync(io_handler_sp);
331}
332
334 WatchpointOptions *wp_options, CommandReturnObject &result) {
335 IOHandlerSP io_handler_sp(
337 io_handler_sp->SetUserData(wp_options);
338 m_debugger.RunIOHandlerAsync(io_handler_sp);
339}
340
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
351 BreakpointOptions &bp_options, const char *command_body_text) {
352 return RegisterBreakpointCallback(bp_options, command_body_text, {});
353}
354
356 BreakpointOptions &bp_options, const char *command_body_text,
357 StructuredData::ObjectSP extra_args_sp) {
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));
366 baton_sp);
367 return error;
368}
369
371 WatchpointOptions *wp_options, const char *command_body_text) {
372 RegisterWatchpointCallback(wp_options, command_body_text, {});
373}
374
376 WatchpointOptions *wp_options, const char *command_body_text,
377 StructuredData::ObjectSP extra_args_sp) {
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));
386 baton_sp);
387 return error;
388}
389
390lldb::ScriptInterpreterSP
392 return std::make_shared<ScriptInterpreterLua>(debugger);
393}
394
396 return "Lua script interpreter";
397}
398
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
@ eIOHandlerWatchpoint
@ eIOHandlerBreakpoint
@ eIOHandlerNone
#define LLDB_SCOPED_TIMER()
Definition: Timer.h:83
IOHandlerLuaInterpreter(Debugger &debugger, ScriptInterpreterLua &script_interpreter, ActiveIOHandler active_io_handler=eIOHandlerNone)
void IOHandlerActivated(IOHandler &io_handler, bool interactive) override
ScriptInterpreterLua & m_script_interpreter
bool IOHandlerIsInputComplete(IOHandler &io_handler, StringList &lines) override
Called to determine whether typing enter after the last line in lines should end input.
bool IsQuitCommand(llvm::StringRef cmd)
void IOHandlerInputComplete(IOHandler &io_handler, std::string &data) override
Called when a line or lines have been retrieved.
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
void SetCallback(BreakpointHitCallback callback, const lldb::BatonSP &baton_sp, bool synchronous=false)
Adds a callback to the breakpoint option set.
void AppendErrorWithFormatv(const char *format, Args &&... args)
void void AppendError(llvm::StringRef in_string)
A class to manage flag bits.
Definition: Debugger.h:77
StreamFile & GetErrorStream()
Definition: Debugger.h:150
void RunIOHandlerAsync(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
Run the given IO handler and return immediately.
Definition: Debugger.cpp:1093
ScriptInterpreter * GetScriptInterpreter(bool can_create=true, std::optional< lldb::ScriptLanguage > language={})
Definition: Debugger.cpp:1496
File & GetOutputFile()
Definition: Debugger.h:144
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::StackFrameSP & GetFrameSP() const
Get accessor to get the frame shared pointer.
Target * GetTargetPtr() const
Returns a pointer to the target object.
A file utility class.
Definition: FileSpec.h:56
virtual FILE * GetStream()
Get the underlying libc stream for this file, or NULL.
Definition: File.cpp:127
bool IsValid() const override
IsValid.
Definition: File.cpp:112
A delegate class for use with IOHandler subclasses.
Definition: IOHandler.h:191
bool SetPrompt(llvm::StringRef prompt) override
Definition: IOHandler.cpp:473
lldb::StreamFileSP GetErrorStreamFileSP()
Definition: IOHandler.cpp:107
lldb::StreamFileSP GetOutputStreamFileSP()
Definition: IOHandler.cpp:105
void SetIsDone(bool b)
Definition: IOHandler.h:87
llvm::Expected< bool > CallWatchpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp)
Definition: Lua.cpp:107
llvm::Error CheckSyntax(llvm::StringRef buffer)
Definition: Lua.cpp:116
llvm::Error ChangeIO(FILE *out, FILE *err)
Definition: Lua.cpp:162
llvm::Error Run(llvm::StringRef buffer)
Definition: Lua.cpp:47
llvm::Expected< bool > CallBreakpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp, lldb::BreakpointLocationSP bp_loc_sp, StructuredData::ObjectSP extra_args_sp)
Definition: Lua.cpp:79
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
void Flush()
Flush our output and error file handles.
static llvm::Expected< std::unique_ptr< ScriptInterpreterIORedirect > > Create(bool enable_io, Debugger &debugger, CommandReturnObject *result)
Create an IO redirect.
Status SetBreakpointCommandCallbackFunction(BreakpointOptions &bp_options, const char *function_name, StructuredData::ObjectSP extra_args_sp) override
Set a script function as the callback for the breakpoint.
void SetWatchpointCommandCallback(WatchpointOptions *wp_options, const char *command_body_text) override
Set a one-liner as the callback for the watchpoint.
llvm::Error EnterSession(lldb::user_id_t debugger_id)
static bool WatchpointCallbackFunction(void *baton, StoppointCallbackContext *context, lldb::user_id_t watch_id)
static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger)
static bool BreakpointCallbackFunction(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
bool LoadScriptingModule(const char *filename, const LoadScriptOptions &options, lldb_private::Status &error, StructuredData::ObjectSP *module_sp=nullptr, FileSpec extra_search_dir={}) override
void CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options, CommandReturnObject &result) override
bool ExecuteOneLine(llvm::StringRef command, CommandReturnObject *result, const ExecuteScriptOptions &options=ExecuteScriptOptions()) override
Status RegisterBreakpointCallback(BreakpointOptions &bp_options, const char *command_body_text, StructuredData::ObjectSP extra_args_sp)
static llvm::StringRef GetPluginNameStatic()
void CollectDataForBreakpointCommandCallback(std::vector< std::reference_wrapper< BreakpointOptions > > &bp_options_vec, CommandReturnObject &result) override
StructuredData::DictionarySP GetInterpreterInfo() override
static llvm::StringRef GetPluginDescriptionStatic()
Status SetBreakpointCommandCallback(BreakpointOptions &bp_options, const char *command_body_text) override
Status RegisterWatchpointCallback(WatchpointOptions *wp_options, const char *command_body_text, StructuredData::ObjectSP extra_args_sp)
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
llvm::StringRef GetString() const
const char * GetStringAtIndex(size_t idx) const
Definition: StringList.cpp:86
size_t GetSize() const
Definition: StringList.cpp:74
void DeleteStringAtIndex(size_t id)
Definition: StringList.cpp:147
void Join(const char *separator, Stream &strm)
Definition: StringList.cpp:92
std::shared_ptr< Dictionary > DictionarySP
std::shared_ptr< Object > ObjectSP
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:324
Debugger & GetDebugger()
Definition: Target.h:1029
WatchpointList & GetWatchpointList()
Definition: Target.h:740
lldb::WatchpointSP FindByID(lldb::watch_id_t watchID) const
Returns a shared pointer to the watchpoint with id watchID, const version.
"lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a watchpoint.
void SetCallback(WatchpointHitCallback callback, const lldb::BatonSP &baton_sp, bool synchronous=false)
Adds a callback to the watchpoint option set.
A class that represents a running process on the host machine.
const char * toString(AppleArm64ExceptionClass EC)
Definition: SBAddress.h:15
@ eScriptLanguageLua
uint64_t user_id_t
Definition: lldb-types.h:84
Definition: Debugger.h:51
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47