lldb/source/Interpreter/ScriptInterpreter.cpp

   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 }