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