1 //===-- ScriptInterpreter.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 "lldb/Interpreter/ScriptInterpreter.h"
10 #include "lldb/Core/Debugger.h"
11 #include "lldb/Host/ConnectionFileDescriptor.h"
12 #include "lldb/Host/Pipe.h"
13 #include "lldb/Host/PseudoTerminal.h"
14 #include "lldb/Interpreter/CommandReturnObject.h"
15 #include "lldb/Utility/Status.h"
16 #include "lldb/Utility/Stream.h"
17 #include "lldb/Utility/StringList.h"
18 #if defined(_WIN32)
19 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
20 #endif
21 #include <cstdio>
22 #include <cstdlib>
23 #include <memory>
24 #include <optional>
25 #include <string>
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 ScriptInterpreter::ScriptInterpreter(
31     Debugger &debugger, lldb::ScriptLanguage script_lang,
32     lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up)
33     : m_debugger(debugger), m_script_lang(script_lang),
34       m_scripted_platform_interface_up(
35           std::move(scripted_platform_interface_up)) {}
36 
37 void ScriptInterpreter::CollectDataForBreakpointCommandCallback(
38     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
39     CommandReturnObject &result) {
40   result.AppendError(
41       "This script interpreter does not support breakpoint callbacks.");
42 }
43 
44 void ScriptInterpreter::CollectDataForWatchpointCommandCallback(
45     WatchpointOptions *bp_options, CommandReturnObject &result) {
46   result.AppendError(
47       "This script interpreter does not support watchpoint callbacks.");
48 }
49 
50 StructuredData::DictionarySP ScriptInterpreter::GetInterpreterInfo() {
51   return nullptr;
52 }
53 
54 bool ScriptInterpreter::LoadScriptingModule(const char *filename,
55                                             const LoadScriptOptions &options,
56                                             lldb_private::Status &error,
57                                             StructuredData::ObjectSP *module_sp,
58                                             FileSpec extra_search_dir) {
59   error.SetErrorString(
60       "This script interpreter does not support importing modules.");
61   return false;
62 }
63 
64 std::string ScriptInterpreter::LanguageToString(lldb::ScriptLanguage language) {
65   switch (language) {
66   case eScriptLanguageNone:
67     return "None";
68   case eScriptLanguagePython:
69     return "Python";
70   case eScriptLanguageLua:
71     return "Lua";
72   case eScriptLanguageUnknown:
73     return "Unknown";
74   }
75   llvm_unreachable("Unhandled ScriptInterpreter!");
76 }
77 
78 lldb::DataExtractorSP
79 ScriptInterpreter::GetDataExtractorFromSBData(const lldb::SBData &data) const {
80   return data.m_opaque_sp;
81 }
82 
83 lldb::BreakpointSP ScriptInterpreter::GetOpaqueTypeFromSBBreakpoint(
84     const lldb::SBBreakpoint &breakpoint) const {
85   return breakpoint.m_opaque_wp.lock();
86 }
87 
88 lldb::ProcessAttachInfoSP ScriptInterpreter::GetOpaqueTypeFromSBAttachInfo(
89     const lldb::SBAttachInfo &attach_info) const {
90   return attach_info.m_opaque_sp;
91 }
92 
93 lldb::ProcessLaunchInfoSP ScriptInterpreter::GetOpaqueTypeFromSBLaunchInfo(
94     const lldb::SBLaunchInfo &launch_info) const {
95   return std::make_shared<ProcessLaunchInfo>(
96       *reinterpret_cast<ProcessLaunchInfo *>(launch_info.m_opaque_sp.get()));
97 }
98 
99 Status
100 ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
101   if (error.m_opaque_up)
102     return *error.m_opaque_up;
103 
104   return Status();
105 }
106 
107 std::optional<MemoryRegionInfo>
108 ScriptInterpreter::GetOpaqueTypeFromSBMemoryRegionInfo(
109     const lldb::SBMemoryRegionInfo &mem_region) const {
110   if (!mem_region.m_opaque_up)
111     return std::nullopt;
112   return *mem_region.m_opaque_up.get();
113 }
114 
115 lldb::ScriptLanguage
116 ScriptInterpreter::StringToLanguage(const llvm::StringRef &language) {
117   if (language.equals_insensitive(LanguageToString(eScriptLanguageNone)))
118     return eScriptLanguageNone;
119   if (language.equals_insensitive(LanguageToString(eScriptLanguagePython)))
120     return eScriptLanguagePython;
121   if (language.equals_insensitive(LanguageToString(eScriptLanguageLua)))
122     return eScriptLanguageLua;
123   return eScriptLanguageUnknown;
124 }
125 
126 Status ScriptInterpreter::SetBreakpointCommandCallback(
127     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
128     const char *callback_text) {
129   Status error;
130   for (BreakpointOptions &bp_options : bp_options_vec) {
131     error = SetBreakpointCommandCallback(bp_options, callback_text,
132                                          /*is_callback=*/false);
133     if (!error.Success())
134       break;
135   }
136   return error;
137 }
138 
139 Status ScriptInterpreter::SetBreakpointCommandCallbackFunction(
140     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
141     const char *function_name, StructuredData::ObjectSP extra_args_sp) {
142   Status error;
143   for (BreakpointOptions &bp_options : bp_options_vec) {
144     error = SetBreakpointCommandCallbackFunction(bp_options, function_name,
145                                                  extra_args_sp);
146     if (!error.Success())
147       return error;
148   }
149   return error;
150 }
151 
152 std::unique_ptr<ScriptInterpreterLocker>
153 ScriptInterpreter::AcquireInterpreterLock() {
154   return std::make_unique<ScriptInterpreterLocker>();
155 }
156 
157 static void ReadThreadBytesReceived(void *baton, const void *src,
158                                     size_t src_len) {
159   if (src && src_len) {
160     Stream *strm = (Stream *)baton;
161     strm->Write(src, src_len);
162     strm->Flush();
163   }
164 }
165 
166 llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
167 ScriptInterpreterIORedirect::Create(bool enable_io, Debugger &debugger,
168                                     CommandReturnObject *result) {
169   if (enable_io)
170     return std::unique_ptr<ScriptInterpreterIORedirect>(
171         new ScriptInterpreterIORedirect(debugger, result));
172 
173   auto nullin = FileSystem::Instance().Open(FileSpec(FileSystem::DEV_NULL),
174                                             File::eOpenOptionReadOnly);
175   if (!nullin)
176     return nullin.takeError();
177 
178   auto nullout = FileSystem::Instance().Open(FileSpec(FileSystem::DEV_NULL),
179                                              File::eOpenOptionWriteOnly);
180   if (!nullout)
181     return nullin.takeError();
182 
183   return std::unique_ptr<ScriptInterpreterIORedirect>(
184       new ScriptInterpreterIORedirect(std::move(*nullin), std::move(*nullout)));
185 }
186 
187 ScriptInterpreterIORedirect::ScriptInterpreterIORedirect(
188     std::unique_ptr<File> input, std::unique_ptr<File> output)
189     : m_input_file_sp(std::move(input)),
190       m_output_file_sp(std::make_shared<StreamFile>(std::move(output))),
191       m_error_file_sp(m_output_file_sp),
192       m_communication("lldb.ScriptInterpreterIORedirect.comm"),
193       m_disconnect(false) {}
194 
195 ScriptInterpreterIORedirect::ScriptInterpreterIORedirect(
196     Debugger &debugger, CommandReturnObject *result)
197     : m_communication("lldb.ScriptInterpreterIORedirect.comm"),
198       m_disconnect(false) {
199 
200   if (result) {
201     m_input_file_sp = debugger.GetInputFileSP();
202 
203     Pipe pipe;
204     Status pipe_result = pipe.CreateNew(false);
205 #if defined(_WIN32)
206     lldb::file_t read_file = pipe.GetReadNativeHandle();
207     pipe.ReleaseReadFileDescriptor();
208     std::unique_ptr<ConnectionGenericFile> conn_up =
209         std::make_unique<ConnectionGenericFile>(read_file, true);
210 #else
211     std::unique_ptr<ConnectionFileDescriptor> conn_up =
212         std::make_unique<ConnectionFileDescriptor>(
213             pipe.ReleaseReadFileDescriptor(), true);
214 #endif
215 
216     if (conn_up->IsConnected()) {
217       m_communication.SetConnection(std::move(conn_up));
218       m_communication.SetReadThreadBytesReceivedCallback(
219           ReadThreadBytesReceived, &result->GetOutputStream());
220       m_communication.StartReadThread();
221       m_disconnect = true;
222 
223       FILE *outfile_handle = fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
224       m_output_file_sp = std::make_shared<StreamFile>(outfile_handle, true);
225       m_error_file_sp = m_output_file_sp;
226       if (outfile_handle)
227         ::setbuf(outfile_handle, nullptr);
228 
229       result->SetImmediateOutputFile(debugger.GetOutputStream().GetFileSP());
230       result->SetImmediateErrorFile(debugger.GetErrorStream().GetFileSP());
231     }
232   }
233 
234   if (!m_input_file_sp || !m_output_file_sp || !m_error_file_sp)
235     debugger.AdoptTopIOHandlerFilesIfInvalid(m_input_file_sp, m_output_file_sp,
236                                              m_error_file_sp);
237 }
238 
239 void ScriptInterpreterIORedirect::Flush() {
240   if (m_output_file_sp)
241     m_output_file_sp->Flush();
242   if (m_error_file_sp)
243     m_error_file_sp->Flush();
244 }
245 
246 ScriptInterpreterIORedirect::~ScriptInterpreterIORedirect() {
247   if (!m_disconnect)
248     return;
249 
250   assert(m_output_file_sp);
251   assert(m_error_file_sp);
252   assert(m_output_file_sp == m_error_file_sp);
253 
254   // Close the write end of the pipe since we are done with our one line
255   // script. This should cause the read thread that output_comm is using to
256   // exit.
257   m_output_file_sp->GetFile().Close();
258   // The close above should cause this thread to exit when it gets to the end
259   // of file, so let it get all its data.
260   m_communication.JoinReadThread();
261   // Now we can close the read end of the pipe.
262   m_communication.Disconnect();
263 }
264