contrib/llvm/tools/lldb/source/Expression/REPL.cpp

   1 //===-- REPL.cpp ------------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Expression/REPL.h"
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Core/StreamFile.h"
  14 #include "lldb/Expression/ExpressionVariable.h"
  15 #include "lldb/Expression/UserExpression.h"
  16 #include "lldb/Host/HostInfo.h"
  17 #include "lldb/Interpreter/CommandInterpreter.h"
  18 #include "lldb/Interpreter/CommandReturnObject.h"
  19 #include "lldb/Target/Target.h"
  20 #include "lldb/Target/Thread.h"
  21 #include "lldb/Utility/AnsiTerminal.h"
  22
  23 using namespace lldb_private;
  24
  25 REPL::REPL(LLVMCastKind kind, Target &target) : m_target(target), m_kind(kind) {
  26   // Make sure all option values have sane defaults
  27   Debugger &debugger = m_target.GetDebugger();
  28   auto exe_ctx = debugger.GetCommandInterpreter().GetExecutionContext();
  29   m_format_options.OptionParsingStarting(&exe_ctx);
  30   m_varobj_options.OptionParsingStarting(&exe_ctx);
  31   m_command_options.OptionParsingStarting(&exe_ctx);
  32
  33   // Default certain settings for REPL regardless of the global settings.
  34   m_command_options.unwind_on_error = false;
  35   m_command_options.ignore_breakpoints = false;
  36   m_command_options.debug = false;
  37 }
  38
  39 REPL::~REPL() = default;
  40
  41 lldb::REPLSP REPL::Create(Status &err, lldb::LanguageType language,
  42                           Debugger *debugger, Target *target,
  43                           const char *repl_options) {
  44   uint32_t idx = 0;
  45   lldb::REPLSP ret;
  46
  47   while (REPLCreateInstance create_instance =
  48              PluginManager::GetREPLCreateCallbackAtIndex(idx++)) {
  49     ret = (*create_instance)(err, language, debugger, target, repl_options);
  50     if (ret) {
  51       break;
  52     }
  53   }
  54
  55   return ret;
  56 }
  57
  58 std::string REPL::GetSourcePath() {
  59   ConstString file_basename = GetSourceFileBasename();
  60   FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
  61   if (tmpdir_file_spec) {
  62     tmpdir_file_spec.GetFilename().SetCString(file_basename.AsCString());
  63     m_repl_source_path = tmpdir_file_spec.GetPath();
  64   } else {
  65     tmpdir_file_spec = FileSpec("/tmp");
  66     tmpdir_file_spec.AppendPathComponent(file_basename.AsCString());
  67   }
  68
  69   return tmpdir_file_spec.GetPath();
  70 }
  71
  72 lldb::IOHandlerSP REPL::GetIOHandler() {
  73   if (!m_io_handler_sp) {
  74     Debugger &debugger = m_target.GetDebugger();
  75     m_io_handler_sp.reset(
  76         new IOHandlerEditline(debugger, IOHandler::Type::REPL,
  77                               "lldb-repl", // Name of input reader for history
  78                               llvm::StringRef("> "), // prompt
  79                               llvm::StringRef(". "), // Continuation prompt
  80                               true,                  // Multi-line
  81                               true, // The REPL prompt is always colored
  82                               1,    // Line number
  83                               *this));
  84
  85     // Don't exit if CTRL+C is pressed
  86     static_cast<IOHandlerEditline *>(m_io_handler_sp.get())
  87         ->SetInterruptExits(false);
  88
  89     if (m_io_handler_sp->GetIsInteractive() &&
  90         m_io_handler_sp->GetIsRealTerminal()) {
  91       m_indent_str.assign(debugger.GetTabSize(), ' ');
  92       m_enable_auto_indent = debugger.GetAutoIndent();
  93     } else {
  94       m_indent_str.clear();
  95       m_enable_auto_indent = false;
  96     }
  97   }
  98   return m_io_handler_sp;
  99 }
 100
 101 void REPL::IOHandlerActivated(IOHandler &io_handler) {
 102   lldb::ProcessSP process_sp = m_target.GetProcessSP();
 103   if (process_sp && process_sp->IsAlive())
 104     return;
 105   lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
 106   error_sp->Printf("REPL requires a running target process.\n");
 107   io_handler.SetIsDone(true);
 108 }
 109
 110 bool REPL::IOHandlerInterrupt(IOHandler &io_handler) { return false; }
 111
 112 void REPL::IOHandlerInputInterrupted(IOHandler &io_handler, std::string &line) {
 113 }
 114
 115 const char *REPL::IOHandlerGetFixIndentationCharacters() {
 116   return (m_enable_auto_indent ? GetAutoIndentCharacters() : nullptr);
 117 }
 118
 119 ConstString REPL::IOHandlerGetControlSequence(char ch) {
 120   if (ch == 'd')
 121     return ConstString(":quit\n");
 122   return ConstString();
 123 }
 124
 125 const char *REPL::IOHandlerGetCommandPrefix() { return ":"; }
 126
 127 const char *REPL::IOHandlerGetHelpPrologue() {
 128   return "\nThe REPL (Read-Eval-Print-Loop) acts like an interpreter.  "
 129          "Valid statements, expressions, and declarations are immediately "
 130          "compiled and executed.\n\n"
 131          "The complete set of LLDB debugging commands are also available as "
 132          "described below.  Commands "
 133          "must be prefixed with a colon at the REPL prompt (:quit for "
 134          "example.)  Typing just a colon "
 135          "followed by return will switch to the LLDB prompt.\n\n";
 136 }
 137
 138 bool REPL::IOHandlerIsInputComplete(IOHandler &io_handler, StringList &lines) {
 139   // Check for meta command
 140   const size_t num_lines = lines.GetSize();
 141   if (num_lines == 1) {
 142     const char *first_line = lines.GetStringAtIndex(0);
 143     if (first_line[0] == ':')
 144       return true; // Meta command is a single line where that starts with ':'
 145   }
 146
 147   // Check if REPL input is done
 148   std::string source_string(lines.CopyList());
 149   return SourceIsComplete(source_string);
 150 }
 151
 152 int REPL::CalculateActualIndentation(const StringList &lines) {
 153   std::string last_line = lines[lines.GetSize() - 1];
 154
 155   int actual_indent = 0;
 156   for (char &ch : last_line) {
 157     if (ch != ' ')
 158       break;
 159     ++actual_indent;
 160   }
 161
 162   return actual_indent;
 163 }
 164
 165 int REPL::IOHandlerFixIndentation(IOHandler &io_handler,
 166                                   const StringList &lines,
 167                                   int cursor_position) {
 168   if (!m_enable_auto_indent)
 169     return 0;
 170
 171   if (!lines.GetSize()) {
 172     return 0;
 173   }
 174
 175   int tab_size = io_handler.GetDebugger().GetTabSize();
 176
 177   lldb::offset_t desired_indent =
 178       GetDesiredIndentation(lines, cursor_position, tab_size);
 179
 180   int actual_indent = REPL::CalculateActualIndentation(lines);
 181
 182   if (desired_indent == LLDB_INVALID_OFFSET)
 183     return 0;
 184
 185   return (int)desired_indent - actual_indent;
 186 }
 187
 188 void REPL::IOHandlerInputComplete(IOHandler &io_handler, std::string &code) {
 189   lldb::StreamFileSP output_sp(io_handler.GetOutputStreamFile());
 190   lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
 191   bool extra_line = false;
 192   bool did_quit = false;
 193
 194   if (code.empty()) {
 195     m_code.AppendString("");
 196     static_cast<IOHandlerEditline &>(io_handler)
 197         .SetBaseLineNumber(m_code.GetSize() + 1);
 198   } else {
 199     Debugger &debugger = m_target.GetDebugger();
 200     CommandInterpreter &ci = debugger.GetCommandInterpreter();
 201     extra_line = ci.GetSpaceReplPrompts();
 202
 203     ExecutionContext exe_ctx(m_target.GetProcessSP()
 204                                  ->GetThreadList()
 205                                  .GetSelectedThread()
 206                                  ->GetSelectedFrame()
 207                                  .get());
 208
 209     lldb::ProcessSP process_sp(exe_ctx.GetProcessSP());
 210
 211     if (code[0] == ':') {
 212       // Meta command
 213       // Strip the ':'
 214       code.erase(0, 1);
 215       if (Args::StripSpaces(code)) {
 216         // "lldb" was followed by arguments, so just execute the command dump
 217         // the results
 218
 219         // Turn off prompt on quit in case the user types ":quit"
 220         const bool saved_prompt_on_quit = ci.GetPromptOnQuit();
 221         if (saved_prompt_on_quit)
 222           ci.SetPromptOnQuit(false);
 223
 224         // Execute the command
 225         CommandReturnObject result;
 226         result.SetImmediateOutputStream(output_sp);
 227         result.SetImmediateErrorStream(error_sp);
 228         ci.HandleCommand(code.c_str(), eLazyBoolNo, result);
 229
 230         if (saved_prompt_on_quit)
 231           ci.SetPromptOnQuit(true);
 232
 233         if (result.GetStatus() == lldb::eReturnStatusQuit) {
 234           did_quit = true;
 235           io_handler.SetIsDone(true);
 236           if (debugger.CheckTopIOHandlerTypes(
 237                   IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter)) {
 238             // We typed "quit" or an alias to quit so we need to check if the
 239             // command interpreter is above us and tell it that it is done as
 240             // well so we don't drop back into the command interpreter if we
 241             // have already quit
 242             lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
 243             if (io_handler_sp)
 244               io_handler_sp->SetIsDone(true);
 245           }
 246         }
 247       } else {
 248         // ":" was followed by no arguments, so push the LLDB command prompt
 249         if (debugger.CheckTopIOHandlerTypes(
 250                 IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter)) {
 251           // If the user wants to get back to the command interpreter and the
 252           // command interpreter is what launched the REPL, then just let the
 253           // REPL exit and fall back to the command interpreter.
 254           io_handler.SetIsDone(true);
 255         } else {
 256           // The REPL wasn't launched the by the command interpreter, it is the
 257           // base IOHandler, so we need to get the command interpreter and
 258           lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
 259           if (io_handler_sp) {
 260             io_handler_sp->SetIsDone(false);
 261             debugger.PushIOHandler(ci.GetIOHandler());
 262           }
 263         }
 264       }
 265     } else {
 266       // Unwind any expression we might have been running in case our REPL
 267       // expression crashed and the user was looking around
 268       if (m_dedicated_repl_mode) {
 269         Thread *thread = exe_ctx.GetThreadPtr();
 270         if (thread && thread->UnwindInnermostExpression().Success()) {
 271           thread->SetSelectedFrameByIndex(0, false);
 272           exe_ctx.SetFrameSP(thread->GetSelectedFrame());
 273         }
 274       }
 275
 276       const bool colorize_err = error_sp->GetFile().GetIsTerminalWithColors();
 277
 278       EvaluateExpressionOptions expr_options;
 279       expr_options.SetCoerceToId(m_varobj_options.use_objc);
 280       expr_options.SetUnwindOnError(m_command_options.unwind_on_error);
 281       expr_options.SetIgnoreBreakpoints(m_command_options.ignore_breakpoints);
 282       expr_options.SetKeepInMemory(true);
 283       expr_options.SetUseDynamic(m_varobj_options.use_dynamic);
 284       expr_options.SetTryAllThreads(m_command_options.try_all_threads);
 285       expr_options.SetGenerateDebugInfo(true);
 286       expr_options.SetREPLEnabled(true);
 287       expr_options.SetColorizeErrors(colorize_err);
 288       expr_options.SetPoundLine(m_repl_source_path.c_str(),
 289                                 m_code.GetSize() + 1);
 290       if (m_command_options.timeout > 0)
 291         expr_options.SetTimeout(std::chrono::microseconds(m_command_options.timeout));
 292       else
 293         expr_options.SetTimeout(llvm::None);
 294
 295       expr_options.SetLanguage(GetLanguage());
 296
 297       PersistentExpressionState *persistent_state =
 298           m_target.GetPersistentExpressionStateForLanguage(GetLanguage());
 299
 300       const size_t var_count_before = persistent_state->GetSize();
 301
 302       const char *expr_prefix = nullptr;
 303       lldb::ValueObjectSP result_valobj_sp;
 304       Status error;
 305       lldb::ModuleSP jit_module_sp;
 306       lldb::ExpressionResults execution_results =
 307           UserExpression::Evaluate(exe_ctx, expr_options, code.c_str(),
 308                                    expr_prefix, result_valobj_sp, error,
 309                                    0,       // Line offset
 310                                    nullptr, // Fixed Expression
 311                                    &jit_module_sp);
 312
 313       // CommandInterpreter &ci = debugger.GetCommandInterpreter();
 314
 315       if (process_sp && process_sp->IsAlive()) {
 316         bool add_to_code = true;
 317         bool handled = false;
 318         if (result_valobj_sp) {
 319           lldb::Format format = m_format_options.GetFormat();
 320
 321           if (result_valobj_sp->GetError().Success()) {
 322             handled |= PrintOneVariable(debugger, output_sp, result_valobj_sp);
 323           } else if (result_valobj_sp->GetError().GetError() ==
 324                      UserExpression::kNoResult) {
 325             if (format != lldb::eFormatVoid && debugger.GetNotifyVoid()) {
 326               error_sp->PutCString("(void)\n");
 327               handled = true;
 328             }
 329           }
 330         }
 331
 332         if (debugger.GetPrintDecls()) {
 333           for (size_t vi = var_count_before, ve = persistent_state->GetSize();
 334                vi != ve; ++vi) {
 335             lldb::ExpressionVariableSP persistent_var_sp =
 336                 persistent_state->GetVariableAtIndex(vi);
 337             lldb::ValueObjectSP valobj_sp = persistent_var_sp->GetValueObject();
 338
 339             PrintOneVariable(debugger, output_sp, valobj_sp,
 340                              persistent_var_sp.get());
 341           }
 342         }
 343
 344         if (!handled) {
 345           bool useColors = error_sp->GetFile().GetIsTerminalWithColors();
 346           switch (execution_results) {
 347           case lldb::eExpressionSetupError:
 348           case lldb::eExpressionParseError:
 349             add_to_code = false;
 350             LLVM_FALLTHROUGH;
 351           case lldb::eExpressionDiscarded:
 352             error_sp->Printf("%s\n", error.AsCString());
 353             break;
 354
 355           case lldb::eExpressionCompleted:
 356             break;
 357           case lldb::eExpressionInterrupted:
 358             if (useColors) {
 359               error_sp->Printf(ANSI_ESCAPE1(ANSI_FG_COLOR_RED));
 360               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_BOLD));
 361             }
 362             error_sp->Printf("Execution interrupted. ");
 363             if (useColors)
 364               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_NORMAL));
 365             error_sp->Printf("Enter code to recover and continue.\nEnter LLDB "
 366                              "commands to investigate (type :help for "
 367                              "assistance.)\n");
 368             break;
 369
 370           case lldb::eExpressionHitBreakpoint:
 371             // Breakpoint was hit, drop into LLDB command interpreter
 372             if (useColors) {
 373               error_sp->Printf(ANSI_ESCAPE1(ANSI_FG_COLOR_RED));
 374               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_BOLD));
 375             }
 376             output_sp->Printf("Execution stopped at breakpoint.  ");
 377             if (useColors)
 378               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_NORMAL));
 379             output_sp->Printf("Enter LLDB commands to investigate (type help "
 380                               "for assistance.)\n");
 381             {
 382               lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
 383               if (io_handler_sp) {
 384                 io_handler_sp->SetIsDone(false);
 385                 debugger.PushIOHandler(ci.GetIOHandler());
 386               }
 387             }
 388             break;
 389
 390           case lldb::eExpressionTimedOut:
 391             error_sp->Printf("error: timeout\n");
 392             if (error.AsCString())
 393               error_sp->Printf("error: %s\n", error.AsCString());
 394             break;
 395           case lldb::eExpressionResultUnavailable:
 396             // Shoulnd't happen???
 397             error_sp->Printf("error: could not fetch result -- %s\n",
 398                              error.AsCString());
 399             break;
 400           case lldb::eExpressionStoppedForDebug:
 401             // Shoulnd't happen???
 402             error_sp->Printf("error: stopped for debug -- %s\n",
 403                              error.AsCString());
 404             break;
 405           }
 406         }
 407
 408         if (add_to_code) {
 409           const uint32_t new_default_line = m_code.GetSize() + 1;
 410
 411           m_code.SplitIntoLines(code);
 412
 413           // Update our code on disk
 414           if (!m_repl_source_path.empty()) {
 415             lldb_private::File file;
 416             FileSystem::Instance().Open(file, FileSpec(m_repl_source_path),
 417                                         File::eOpenOptionWrite |
 418                                             File::eOpenOptionTruncate |
 419                                             File::eOpenOptionCanCreate,
 420                                         lldb::eFilePermissionsFileDefault);
 421             std::string code(m_code.CopyList());
 422             code.append(1, '\n');
 423             size_t bytes_written = code.size();
 424             file.Write(code.c_str(), bytes_written);
 425             file.Close();
 426
 427             // Now set the default file and line to the REPL source file
 428             m_target.GetSourceManager().SetDefaultFileAndLine(
 429                 FileSpec(m_repl_source_path), new_default_line);
 430           }
 431           static_cast<IOHandlerEditline &>(io_handler)
 432               .SetBaseLineNumber(m_code.GetSize() + 1);
 433         }
 434         if (extra_line) {
 435           fprintf(output_sp->GetFile().GetStream(), "\n");
 436         }
 437       }
 438     }
 439
 440     // Don't complain about the REPL process going away if we are in the
 441     // process of quitting.
 442     if (!did_quit && (!process_sp || !process_sp->IsAlive())) {
 443       error_sp->Printf(
 444           "error: REPL process is no longer alive, exiting REPL\n");
 445       io_handler.SetIsDone(true);
 446     }
 447   }
 448 }
 449
 450 int REPL::IOHandlerComplete(IOHandler &io_handler, const char *current_line,
 451                             const char *cursor, const char *last_char,
 452                             int skip_first_n_matches, int max_matches,
 453                             StringList &matches, StringList &descriptions) {
 454   matches.Clear();
 455
 456   llvm::StringRef line(current_line, cursor - current_line);
 457
 458   // Complete an LLDB command if the first character is a colon...
 459   if (!line.empty() && line[0] == ':') {
 460     Debugger &debugger = m_target.GetDebugger();
 461
 462     // auto complete LLDB commands
 463     const char *lldb_current_line = line.substr(1).data();
 464     return debugger.GetCommandInterpreter().HandleCompletion(
 465         lldb_current_line, cursor, last_char, skip_first_n_matches, max_matches,
 466         matches, descriptions);
 467   }
 468
 469   // Strip spaces from the line and see if we had only spaces
 470   line = line.ltrim();
 471   if (line.empty()) {
 472     // Only spaces on this line, so just indent
 473     matches.AppendString(m_indent_str);
 474     return 1;
 475   }
 476
 477   std::string current_code;
 478   current_code.append(m_code.CopyList());
 479
 480   IOHandlerEditline &editline = static_cast<IOHandlerEditline &>(io_handler);
 481   const StringList *current_lines = editline.GetCurrentLines();
 482   if (current_lines) {
 483     const uint32_t current_line_idx = editline.GetCurrentLineIndex();
 484
 485     if (current_line_idx < current_lines->GetSize()) {
 486       for (uint32_t i = 0; i < current_line_idx; ++i) {
 487         const char *line_cstr = current_lines->GetStringAtIndex(i);
 488         if (line_cstr) {
 489           current_code.append("\n");
 490           current_code.append(line_cstr);
 491         }
 492       }
 493     }
 494   }
 495
 496   if (cursor > current_line) {
 497     current_code.append("\n");
 498     current_code.append(current_line, cursor - current_line);
 499   }
 500
 501   return CompleteCode(current_code, matches);
 502 }
 503
 504 bool QuitCommandOverrideCallback(void *baton, const char **argv) {
 505   Target *target = (Target *)baton;
 506   lldb::ProcessSP process_sp(target->GetProcessSP());
 507   if (process_sp) {
 508     process_sp->Destroy(false);
 509     process_sp->GetTarget().GetDebugger().ClearIOHandlers();
 510   }
 511   return false;
 512 }
 513
 514 Status REPL::RunLoop() {
 515   Status error;
 516
 517   error = DoInitialization();
 518   m_repl_source_path = GetSourcePath();
 519
 520   if (!error.Success())
 521     return error;
 522
 523   Debugger &debugger = m_target.GetDebugger();
 524
 525   lldb::IOHandlerSP io_handler_sp(GetIOHandler());
 526
 527   FileSpec save_default_file;
 528   uint32_t save_default_line = 0;
 529
 530   if (!m_repl_source_path.empty()) {
 531     // Save the current default file and line
 532     m_target.GetSourceManager().GetDefaultFileAndLine(save_default_file,
 533                                                       save_default_line);
 534   }
 535
 536   debugger.PushIOHandler(io_handler_sp);
 537
 538   // Check if we are in dedicated REPL mode where LLDB was start with the "--
 539   // repl" option from the command line. Currently we know this by checking if
 540   // the debugger already has a IOHandler thread.
 541   if (!debugger.HasIOHandlerThread()) {
 542     // The debugger doesn't have an existing IOHandler thread, so this must be
 543     // dedicated REPL mode...
 544     m_dedicated_repl_mode = true;
 545     debugger.StartIOHandlerThread();
 546     llvm::StringRef command_name_str("quit");
 547     CommandObject *cmd_obj =
 548         debugger.GetCommandInterpreter().GetCommandObjectForCommand(
 549             command_name_str);
 550     if (cmd_obj) {
 551       assert(command_name_str.empty());
 552       cmd_obj->SetOverrideCallback(QuitCommandOverrideCallback, &m_target);
 553     }
 554   }
 555
 556   // Wait for the REPL command interpreter to get popped
 557   io_handler_sp->WaitForPop();
 558
 559   if (m_dedicated_repl_mode) {
 560     // If we were in dedicated REPL mode we would have started the IOHandler
 561     // thread, and we should kill our process
 562     lldb::ProcessSP process_sp = m_target.GetProcessSP();
 563     if (process_sp && process_sp->IsAlive())
 564       process_sp->Destroy(false);
 565
 566     // Wait for the IO handler thread to exit (TODO: don't do this if the IO
 567     // handler thread already exists...)
 568     debugger.JoinIOHandlerThread();
 569   }
 570
 571   // Restore the default file and line
 572   if (save_default_file && save_default_line != 0)
 573     m_target.GetSourceManager().SetDefaultFileAndLine(save_default_file,
 574                                                       save_default_line);
 575   return error;
 576 }