1 //===-- Debugger.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/Core/Debugger.h" 11 12 // C Includes 13 // C++ Includes 14 #include <map> 15 16 // Other libraries and framework includes 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/Support/DynamicLibrary.h" 19 20 // Project includes 21 #include "lldb/lldb-private.h" 22 #include "lldb/Core/FormatEntity.h" 23 #include "lldb/Core/Module.h" 24 #include "lldb/Core/PluginInterface.h" 25 #include "lldb/Core/PluginManager.h" 26 #include "lldb/Core/RegisterValue.h" 27 #include "lldb/Core/State.h" 28 #include "lldb/Core/StreamAsynchronousIO.h" 29 #include "lldb/Core/StreamCallback.h" 30 #include "lldb/Core/StreamFile.h" 31 #include "lldb/Core/StreamString.h" 32 #include "lldb/Core/StructuredData.h" 33 #include "lldb/Core/Timer.h" 34 #include "lldb/Core/ValueObject.h" 35 #include "lldb/Core/ValueObjectVariable.h" 36 #include "lldb/DataFormatters/DataVisualization.h" 37 #include "lldb/DataFormatters/FormatManager.h" 38 #include "lldb/DataFormatters/TypeSummary.h" 39 #include "lldb/Expression/REPL.h" 40 #include "lldb/Host/ConnectionFileDescriptor.h" 41 #include "lldb/Host/HostInfo.h" 42 #include "lldb/Host/Terminal.h" 43 #include "lldb/Host/ThreadLauncher.h" 44 #include "lldb/Interpreter/CommandInterpreter.h" 45 #include "lldb/Interpreter/OptionValueProperties.h" 46 #include "lldb/Interpreter/OptionValueSInt64.h" 47 #include "lldb/Interpreter/OptionValueString.h" 48 #include "lldb/Symbol/CompileUnit.h" 49 #include "lldb/Symbol/Function.h" 50 #include "lldb/Symbol/Symbol.h" 51 #include "lldb/Symbol/VariableList.h" 52 #include "lldb/Target/TargetList.h" 53 #include "lldb/Target/Language.h" 54 #include "lldb/Target/Process.h" 55 #include "lldb/Target/RegisterContext.h" 56 #include "lldb/Target/SectionLoadList.h" 57 #include "lldb/Target/StopInfo.h" 58 #include "lldb/Target/Target.h" 59 #include "lldb/Target/Thread.h" 60 #include "lldb/Utility/AnsiTerminal.h" 61 62 using namespace lldb; 63 using namespace lldb_private; 64 65 static lldb::user_id_t g_unique_id = 1; 66 static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024; 67 68 #pragma mark Static Functions 69 70 static Mutex & 71 GetDebuggerListMutex () 72 { 73 static Mutex g_mutex(Mutex::eMutexTypeRecursive); 74 return g_mutex; 75 } 76 77 typedef std::vector<DebuggerSP> DebuggerList; 78 79 static DebuggerList & 80 GetDebuggerList() 81 { 82 // hide the static debugger list inside a singleton accessor to avoid 83 // global init constructors 84 static DebuggerList g_list; 85 return g_list; 86 } 87 88 OptionEnumValueElement 89 g_show_disassembly_enum_values[] = 90 { 91 { Debugger::eStopDisassemblyTypeNever, "never", "Never show disassembly when displaying a stop context."}, 92 { Debugger::eStopDisassemblyTypeNoDebugInfo, "no-debuginfo", "Show disassembly when there is no debug information."}, 93 { Debugger::eStopDisassemblyTypeNoSource, "no-source", "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."}, 94 { Debugger::eStopDisassemblyTypeAlways, "always", "Always show disassembly when displaying a stop context."}, 95 { 0, nullptr, nullptr } 96 }; 97 98 OptionEnumValueElement 99 g_language_enumerators[] = 100 { 101 { eScriptLanguageNone, "none", "Disable scripting languages."}, 102 { eScriptLanguagePython, "python", "Select python as the default scripting language."}, 103 { eScriptLanguageDefault, "default", "Select the lldb default as the default scripting language."}, 104 { 0, nullptr, nullptr } 105 }; 106 107 #define MODULE_WITH_FUNC "{ ${module.file.basename}{`${function.name-with-args}${function.pc-offset}}}" 108 #define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}" 109 #define IS_OPTIMIZED "{${function.is-optimized} [opt]}" 110 111 #define DEFAULT_THREAD_FORMAT "thread #${thread.index}: tid = ${thread.id%tid}"\ 112 "{, ${frame.pc}}"\ 113 MODULE_WITH_FUNC\ 114 FILE_AND_LINE\ 115 "{, name = '${thread.name}'}"\ 116 "{, queue = '${thread.queue}'}"\ 117 "{, activity = '${thread.info.activity.name}'}" \ 118 "{, ${thread.info.trace_messages} messages}" \ 119 "{, stop reason = ${thread.stop-reason}}"\ 120 "{\\nReturn value: ${thread.return-value}}"\ 121 "{\\nCompleted expression: ${thread.completed-expression}}"\ 122 "\\n" 123 124 #define DEFAULT_FRAME_FORMAT "frame #${frame.index}: ${frame.pc}"\ 125 MODULE_WITH_FUNC\ 126 FILE_AND_LINE\ 127 IS_OPTIMIZED\ 128 "\\n" 129 130 // Three parts to this disassembly format specification: 131 // 1. If this is a new function/symbol (no previous symbol/function), print 132 // dylib`funcname:\n 133 // 2. If this is a symbol context change (different from previous symbol/function), print 134 // dylib`funcname:\n 135 // 3. print 136 // address <+offset>: 137 #define DEFAULT_DISASSEMBLY_FORMAT "{${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }${addr-file-or-load}{ <${function.concrete-only-addr-offset-no-padding}>}: " 138 139 // gdb's disassembly format can be emulated with 140 // ${current-pc-arrow}${addr-file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>}: 141 142 // lldb's original format for disassembly would look like this format string - 143 // {${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}: 144 145 static PropertyDefinition 146 g_properties[] = 147 { 148 { "auto-confirm", OptionValue::eTypeBoolean , true, false, nullptr, nullptr, "If true all confirmation prompts will receive their default reply." }, 149 { "disassembly-format", OptionValue::eTypeFormatEntity, true, 0 , DEFAULT_DISASSEMBLY_FORMAT, nullptr, "The default disassembly format string to use when disassembling instruction sequences." }, 150 { "frame-format", OptionValue::eTypeFormatEntity, true, 0 , DEFAULT_FRAME_FORMAT, nullptr, "The default frame format string to use when displaying stack frame information for threads." }, 151 { "notify-void", OptionValue::eTypeBoolean , true, false, nullptr, nullptr, "Notify the user explicitly if an expression returns void (default: false)." }, 152 { "prompt", OptionValue::eTypeString , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", nullptr, "The debugger command line prompt displayed for the user." }, 153 { "script-lang", OptionValue::eTypeEnum , true, eScriptLanguagePython, nullptr, g_language_enumerators, "The script language to be used for evaluating user-written scripts." }, 154 { "stop-disassembly-count", OptionValue::eTypeSInt64 , true, 4 , nullptr, nullptr, "The number of disassembly lines to show when displaying a stopped context." }, 155 { "stop-disassembly-display", OptionValue::eTypeEnum , true, Debugger::eStopDisassemblyTypeNoDebugInfo, nullptr, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." }, 156 { "stop-line-count-after", OptionValue::eTypeSInt64 , true, 3 , nullptr, nullptr, "The number of sources lines to display that come after the current source line when displaying a stopped context." }, 157 { "stop-line-count-before", OptionValue::eTypeSInt64 , true, 3 , nullptr, nullptr, "The number of sources lines to display that come before the current source line when displaying a stopped context." }, 158 { "term-width", OptionValue::eTypeSInt64 , true, 80 , nullptr, nullptr, "The maximum number of columns to use for displaying text." }, 159 { "thread-format", OptionValue::eTypeFormatEntity, true, 0 , DEFAULT_THREAD_FORMAT, nullptr, "The default thread format string to use when displaying thread information." }, 160 { "use-external-editor", OptionValue::eTypeBoolean , true, false, nullptr, nullptr, "Whether to use an external editor or not." }, 161 { "use-color", OptionValue::eTypeBoolean , true, true , nullptr, nullptr, "Whether to use Ansi color codes or not." }, 162 { "auto-one-line-summaries", OptionValue::eTypeBoolean , true, true, nullptr, nullptr, "If true, LLDB will automatically display small structs in one-liner format (default: true)." }, 163 { "auto-indent", OptionValue::eTypeBoolean , true, true , nullptr, nullptr, "If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true)." }, 164 { "print-decls", OptionValue::eTypeBoolean , true, true , nullptr, nullptr, "If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true)." }, 165 { "tab-size", OptionValue::eTypeUInt64 , true, 4 , nullptr, nullptr, "The tab size to use when indenting code in multi-line input mode (default: 4)." }, 166 { "escape-non-printables", OptionValue::eTypeBoolean , true, true, nullptr, nullptr, "If true, LLDB will automatically escape non-printable and escape characters when formatting strings." }, 167 { nullptr, OptionValue::eTypeInvalid , true, 0 , nullptr, nullptr, nullptr } 168 }; 169 170 enum 171 { 172 ePropertyAutoConfirm = 0, 173 ePropertyDisassemblyFormat, 174 ePropertyFrameFormat, 175 ePropertyNotiftVoid, 176 ePropertyPrompt, 177 ePropertyScriptLanguage, 178 ePropertyStopDisassemblyCount, 179 ePropertyStopDisassemblyDisplay, 180 ePropertyStopLineCountAfter, 181 ePropertyStopLineCountBefore, 182 ePropertyTerminalWidth, 183 ePropertyThreadFormat, 184 ePropertyUseExternalEditor, 185 ePropertyUseColor, 186 ePropertyAutoOneLineSummaries, 187 ePropertyAutoIndent, 188 ePropertyPrintDecls, 189 ePropertyTabSize, 190 ePropertyEscapeNonPrintables 191 }; 192 193 LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr; 194 195 Error 196 Debugger::SetPropertyValue (const ExecutionContext *exe_ctx, 197 VarSetOperationType op, 198 const char *property_path, 199 const char *value) 200 { 201 bool is_load_script = strcmp(property_path,"target.load-script-from-symbol-file") == 0; 202 bool is_escape_non_printables = strcmp(property_path, "escape-non-printables") == 0; 203 TargetSP target_sp; 204 LoadScriptFromSymFile load_script_old_value; 205 if (is_load_script && exe_ctx->GetTargetSP()) 206 { 207 target_sp = exe_ctx->GetTargetSP(); 208 load_script_old_value = target_sp->TargetProperties::GetLoadScriptFromSymbolFile(); 209 } 210 Error error (Properties::SetPropertyValue (exe_ctx, op, property_path, value)); 211 if (error.Success()) 212 { 213 // FIXME it would be nice to have "on-change" callbacks for properties 214 if (strcmp(property_path, g_properties[ePropertyPrompt].name) == 0) 215 { 216 const char *new_prompt = GetPrompt(); 217 std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor()); 218 if (str.length()) 219 new_prompt = str.c_str(); 220 GetCommandInterpreter().UpdatePrompt(new_prompt); 221 EventSP prompt_change_event_sp (new Event(CommandInterpreter::eBroadcastBitResetPrompt, new EventDataBytes (new_prompt))); 222 GetCommandInterpreter().BroadcastEvent (prompt_change_event_sp); 223 } 224 else if (strcmp(property_path, g_properties[ePropertyUseColor].name) == 0) 225 { 226 // use-color changed. Ping the prompt so it can reset the ansi terminal codes. 227 SetPrompt (GetPrompt()); 228 } 229 else if (is_load_script && target_sp && load_script_old_value == eLoadScriptFromSymFileWarn) 230 { 231 if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() == eLoadScriptFromSymFileTrue) 232 { 233 std::list<Error> errors; 234 StreamString feedback_stream; 235 if (!target_sp->LoadScriptingResources(errors,&feedback_stream)) 236 { 237 StreamFileSP stream_sp (GetErrorFile()); 238 if (stream_sp) 239 { 240 for (auto error : errors) 241 { 242 stream_sp->Printf("%s\n",error.AsCString()); 243 } 244 if (feedback_stream.GetSize()) 245 stream_sp->Printf("%s",feedback_stream.GetData()); 246 } 247 } 248 } 249 } 250 else if (is_escape_non_printables) 251 { 252 DataVisualization::ForceUpdate(); 253 } 254 } 255 return error; 256 } 257 258 bool 259 Debugger::GetAutoConfirm () const 260 { 261 const uint32_t idx = ePropertyAutoConfirm; 262 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 263 } 264 265 const FormatEntity::Entry * 266 Debugger::GetDisassemblyFormat() const 267 { 268 const uint32_t idx = ePropertyDisassemblyFormat; 269 return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx); 270 } 271 272 const FormatEntity::Entry * 273 Debugger::GetFrameFormat() const 274 { 275 const uint32_t idx = ePropertyFrameFormat; 276 return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx); 277 } 278 279 bool 280 Debugger::GetNotifyVoid () const 281 { 282 const uint32_t idx = ePropertyNotiftVoid; 283 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 284 } 285 286 const char * 287 Debugger::GetPrompt() const 288 { 289 const uint32_t idx = ePropertyPrompt; 290 return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, g_properties[idx].default_cstr_value); 291 } 292 293 void 294 Debugger::SetPrompt(const char *p) 295 { 296 const uint32_t idx = ePropertyPrompt; 297 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 298 const char *new_prompt = GetPrompt(); 299 std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor()); 300 if (str.length()) 301 new_prompt = str.c_str(); 302 GetCommandInterpreter().UpdatePrompt(new_prompt); 303 } 304 305 const FormatEntity::Entry * 306 Debugger::GetThreadFormat() const 307 { 308 const uint32_t idx = ePropertyThreadFormat; 309 return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx); 310 } 311 312 lldb::ScriptLanguage 313 Debugger::GetScriptLanguage() const 314 { 315 const uint32_t idx = ePropertyScriptLanguage; 316 return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 317 } 318 319 bool 320 Debugger::SetScriptLanguage (lldb::ScriptLanguage script_lang) 321 { 322 const uint32_t idx = ePropertyScriptLanguage; 323 return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, script_lang); 324 } 325 326 uint32_t 327 Debugger::GetTerminalWidth () const 328 { 329 const uint32_t idx = ePropertyTerminalWidth; 330 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 331 } 332 333 bool 334 Debugger::SetTerminalWidth (uint32_t term_width) 335 { 336 const uint32_t idx = ePropertyTerminalWidth; 337 return m_collection_sp->SetPropertyAtIndexAsSInt64(nullptr, idx, term_width); 338 } 339 340 bool 341 Debugger::GetUseExternalEditor () const 342 { 343 const uint32_t idx = ePropertyUseExternalEditor; 344 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 345 } 346 347 bool 348 Debugger::SetUseExternalEditor (bool b) 349 { 350 const uint32_t idx = ePropertyUseExternalEditor; 351 return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 352 } 353 354 bool 355 Debugger::GetUseColor () const 356 { 357 const uint32_t idx = ePropertyUseColor; 358 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 359 } 360 361 bool 362 Debugger::SetUseColor (bool b) 363 { 364 const uint32_t idx = ePropertyUseColor; 365 bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 366 SetPrompt (GetPrompt()); 367 return ret; 368 } 369 370 uint32_t 371 Debugger::GetStopSourceLineCount (bool before) const 372 { 373 const uint32_t idx = before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter; 374 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 375 } 376 377 Debugger::StopDisassemblyType 378 Debugger::GetStopDisassemblyDisplay () const 379 { 380 const uint32_t idx = ePropertyStopDisassemblyDisplay; 381 return (Debugger::StopDisassemblyType)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 382 } 383 384 uint32_t 385 Debugger::GetDisassemblyLineCount () const 386 { 387 const uint32_t idx = ePropertyStopDisassemblyCount; 388 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 389 } 390 391 bool 392 Debugger::GetAutoOneLineSummaries () const 393 { 394 const uint32_t idx = ePropertyAutoOneLineSummaries; 395 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true); 396 } 397 398 bool 399 Debugger::GetEscapeNonPrintables () const 400 { 401 const uint32_t idx = ePropertyEscapeNonPrintables; 402 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true); 403 } 404 405 bool 406 Debugger::GetAutoIndent () const 407 { 408 const uint32_t idx = ePropertyAutoIndent; 409 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true); 410 } 411 412 bool 413 Debugger::SetAutoIndent (bool b) 414 { 415 const uint32_t idx = ePropertyAutoIndent; 416 return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 417 } 418 419 bool 420 Debugger::GetPrintDecls () const 421 { 422 const uint32_t idx = ePropertyPrintDecls; 423 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true); 424 } 425 426 bool 427 Debugger::SetPrintDecls (bool b) 428 { 429 const uint32_t idx = ePropertyPrintDecls; 430 return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 431 } 432 433 uint32_t 434 Debugger::GetTabSize () const 435 { 436 const uint32_t idx = ePropertyTabSize; 437 return m_collection_sp->GetPropertyAtIndexAsUInt64(nullptr, idx, g_properties[idx].default_uint_value); 438 } 439 440 bool 441 Debugger::SetTabSize (uint32_t tab_size) 442 { 443 const uint32_t idx = ePropertyTabSize; 444 return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size); 445 } 446 447 #pragma mark Debugger 448 449 //const DebuggerPropertiesSP & 450 //Debugger::GetSettings() const 451 //{ 452 // return m_properties_sp; 453 //} 454 // 455 456 static bool lldb_initialized = false; 457 void 458 Debugger::Initialize(LoadPluginCallbackType load_plugin_callback) 459 { 460 assert(!lldb_initialized && "Debugger::Initialize called more than once!"); 461 462 lldb_initialized = true; 463 g_load_plugin_callback = load_plugin_callback; 464 } 465 466 void 467 Debugger::Terminate () 468 { 469 assert(lldb_initialized && "Debugger::Terminate called without a matching Debugger::Initialize!"); 470 471 // Clear our master list of debugger objects 472 Mutex::Locker locker (GetDebuggerListMutex ()); 473 auto& debuggers = GetDebuggerList(); 474 for (const auto& debugger: debuggers) 475 debugger->Clear(); 476 477 debuggers.clear(); 478 } 479 480 void 481 Debugger::SettingsInitialize () 482 { 483 Target::SettingsInitialize (); 484 } 485 486 void 487 Debugger::SettingsTerminate () 488 { 489 Target::SettingsTerminate (); 490 } 491 492 bool 493 Debugger::LoadPlugin (const FileSpec& spec, Error& error) 494 { 495 if (g_load_plugin_callback) 496 { 497 llvm::sys::DynamicLibrary dynlib = g_load_plugin_callback (shared_from_this(), spec, error); 498 if (dynlib.isValid()) 499 { 500 m_loaded_plugins.push_back(dynlib); 501 return true; 502 } 503 } 504 else 505 { 506 // The g_load_plugin_callback is registered in SBDebugger::Initialize() 507 // and if the public API layer isn't available (code is linking against 508 // all of the internal LLDB static libraries), then we can't load plugins 509 error.SetErrorString("Public API layer is not available"); 510 } 511 return false; 512 } 513 514 static FileSpec::EnumerateDirectoryResult 515 LoadPluginCallback(void *baton, 516 FileSpec::FileType file_type, 517 const FileSpec &file_spec) 518 { 519 Error error; 520 521 static ConstString g_dylibext("dylib"); 522 static ConstString g_solibext("so"); 523 524 if (!baton) 525 return FileSpec::eEnumerateDirectoryResultQuit; 526 527 Debugger *debugger = (Debugger*)baton; 528 529 // If we have a regular file, a symbolic link or unknown file type, try 530 // and process the file. We must handle unknown as sometimes the directory 531 // enumeration might be enumerating a file system that doesn't have correct 532 // file type information. 533 if (file_type == FileSpec::eFileTypeRegular || 534 file_type == FileSpec::eFileTypeSymbolicLink || 535 file_type == FileSpec::eFileTypeUnknown ) 536 { 537 FileSpec plugin_file_spec (file_spec); 538 plugin_file_spec.ResolvePath (); 539 540 if (plugin_file_spec.GetFileNameExtension() != g_dylibext && 541 plugin_file_spec.GetFileNameExtension() != g_solibext) 542 { 543 return FileSpec::eEnumerateDirectoryResultNext; 544 } 545 546 Error plugin_load_error; 547 debugger->LoadPlugin (plugin_file_spec, plugin_load_error); 548 549 return FileSpec::eEnumerateDirectoryResultNext; 550 } 551 else if (file_type == FileSpec::eFileTypeUnknown || 552 file_type == FileSpec::eFileTypeDirectory || 553 file_type == FileSpec::eFileTypeSymbolicLink ) 554 { 555 // Try and recurse into anything that a directory or symbolic link. 556 // We must also do this for unknown as sometimes the directory enumeration 557 // might be enumerating a file system that doesn't have correct file type 558 // information. 559 return FileSpec::eEnumerateDirectoryResultEnter; 560 } 561 562 return FileSpec::eEnumerateDirectoryResultNext; 563 } 564 565 void 566 Debugger::InstanceInitialize () 567 { 568 FileSpec dir_spec; 569 const bool find_directories = true; 570 const bool find_files = true; 571 const bool find_other = true; 572 char dir_path[PATH_MAX]; 573 if (HostInfo::GetLLDBPath(ePathTypeLLDBSystemPlugins, dir_spec)) 574 { 575 if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) 576 { 577 FileSpec::EnumerateDirectory (dir_path, 578 find_directories, 579 find_files, 580 find_other, 581 LoadPluginCallback, 582 this); 583 } 584 } 585 586 if (HostInfo::GetLLDBPath(ePathTypeLLDBUserPlugins, dir_spec)) 587 { 588 if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) 589 { 590 FileSpec::EnumerateDirectory (dir_path, 591 find_directories, 592 find_files, 593 find_other, 594 LoadPluginCallback, 595 this); 596 } 597 } 598 599 PluginManager::DebuggerInitialize (*this); 600 } 601 602 DebuggerSP 603 Debugger::CreateInstance (lldb::LogOutputCallback log_callback, void *baton) 604 { 605 DebuggerSP debugger_sp (new Debugger(log_callback, baton)); 606 if (lldb_initialized) 607 { 608 Mutex::Locker locker (GetDebuggerListMutex ()); 609 GetDebuggerList().push_back(debugger_sp); 610 } 611 debugger_sp->InstanceInitialize (); 612 return debugger_sp; 613 } 614 615 void 616 Debugger::Destroy (DebuggerSP &debugger_sp) 617 { 618 if (!debugger_sp) 619 return; 620 621 debugger_sp->Clear(); 622 623 if (lldb_initialized) 624 { 625 Mutex::Locker locker (GetDebuggerListMutex ()); 626 DebuggerList &debugger_list = GetDebuggerList (); 627 DebuggerList::iterator pos, end = debugger_list.end(); 628 for (pos = debugger_list.begin (); pos != end; ++pos) 629 { 630 if ((*pos).get() == debugger_sp.get()) 631 { 632 debugger_list.erase (pos); 633 return; 634 } 635 } 636 } 637 } 638 639 DebuggerSP 640 Debugger::FindDebuggerWithInstanceName (const ConstString &instance_name) 641 { 642 DebuggerSP debugger_sp; 643 if (lldb_initialized) 644 { 645 Mutex::Locker locker (GetDebuggerListMutex ()); 646 DebuggerList &debugger_list = GetDebuggerList(); 647 DebuggerList::iterator pos, end = debugger_list.end(); 648 649 for (pos = debugger_list.begin(); pos != end; ++pos) 650 { 651 if ((*pos)->m_instance_name == instance_name) 652 { 653 debugger_sp = *pos; 654 break; 655 } 656 } 657 } 658 return debugger_sp; 659 } 660 661 TargetSP 662 Debugger::FindTargetWithProcessID (lldb::pid_t pid) 663 { 664 TargetSP target_sp; 665 if (lldb_initialized) 666 { 667 Mutex::Locker locker (GetDebuggerListMutex ()); 668 DebuggerList &debugger_list = GetDebuggerList(); 669 DebuggerList::iterator pos, end = debugger_list.end(); 670 for (pos = debugger_list.begin(); pos != end; ++pos) 671 { 672 target_sp = (*pos)->GetTargetList().FindTargetWithProcessID (pid); 673 if (target_sp) 674 break; 675 } 676 } 677 return target_sp; 678 } 679 680 TargetSP 681 Debugger::FindTargetWithProcess (Process *process) 682 { 683 TargetSP target_sp; 684 if (lldb_initialized) 685 { 686 Mutex::Locker locker (GetDebuggerListMutex ()); 687 DebuggerList &debugger_list = GetDebuggerList(); 688 DebuggerList::iterator pos, end = debugger_list.end(); 689 for (pos = debugger_list.begin(); pos != end; ++pos) 690 { 691 target_sp = (*pos)->GetTargetList().FindTargetWithProcess (process); 692 if (target_sp) 693 break; 694 } 695 } 696 return target_sp; 697 } 698 699 Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) : 700 UserID(g_unique_id++), 701 Properties(OptionValuePropertiesSP(new OptionValueProperties())), 702 m_input_file_sp(new StreamFile(stdin, false)), 703 m_output_file_sp(new StreamFile(stdout, false)), 704 m_error_file_sp(new StreamFile(stderr, false)), 705 m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()), 706 m_terminal_state(), 707 m_target_list(*this), 708 m_platform_list(), 709 m_listener_sp(Listener::MakeListener("lldb.Debugger")), 710 m_source_manager_ap(), 711 m_source_file_cache(), 712 m_command_interpreter_ap(new CommandInterpreter(*this, eScriptLanguageDefault, false)), 713 m_input_reader_stack(), 714 m_instance_name(), 715 m_loaded_plugins(), 716 m_event_handler_thread(), 717 m_io_handler_thread(), 718 m_sync_broadcaster(nullptr, "lldb.debugger.sync"), 719 m_forward_listener_sp(), 720 m_clear_once() 721 { 722 char instance_cstr[256]; 723 snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID()); 724 m_instance_name.SetCString(instance_cstr); 725 if (log_callback) 726 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton)); 727 m_command_interpreter_ap->Initialize (); 728 // Always add our default platform to the platform list 729 PlatformSP default_platform_sp (Platform::GetHostPlatform()); 730 assert(default_platform_sp); 731 m_platform_list.Append (default_platform_sp, true); 732 733 m_collection_sp->Initialize (g_properties); 734 m_collection_sp->AppendProperty (ConstString("target"), 735 ConstString("Settings specify to debugging targets."), 736 true, 737 Target::GetGlobalProperties()->GetValueProperties()); 738 m_collection_sp->AppendProperty (ConstString("platform"), 739 ConstString("Platform settings."), 740 true, 741 Platform::GetGlobalPlatformProperties()->GetValueProperties()); 742 if (m_command_interpreter_ap) 743 { 744 m_collection_sp->AppendProperty (ConstString("interpreter"), 745 ConstString("Settings specify to the debugger's command interpreter."), 746 true, 747 m_command_interpreter_ap->GetValueProperties()); 748 } 749 OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(nullptr, ePropertyTerminalWidth); 750 term_width->SetMinimumValue(10); 751 term_width->SetMaximumValue(1024); 752 753 // Turn off use-color if this is a dumb terminal. 754 const char *term = getenv ("TERM"); 755 if (term && !strcmp (term, "dumb")) 756 SetUseColor (false); 757 } 758 759 Debugger::~Debugger () 760 { 761 Clear(); 762 } 763 764 void 765 Debugger::Clear() 766 { 767 //---------------------------------------------------------------------- 768 // Make sure we call this function only once. With the C++ global 769 // destructor chain having a list of debuggers and with code that can be 770 // running on other threads, we need to ensure this doesn't happen 771 // multiple times. 772 // 773 // The following functions call Debugger::Clear(): 774 // Debugger::~Debugger(); 775 // static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp); 776 // static void Debugger::Terminate(); 777 //---------------------------------------------------------------------- 778 std::call_once(m_clear_once, [this]() { 779 ClearIOHandlers(); 780 StopIOHandlerThread(); 781 StopEventHandlerThread(); 782 m_listener_sp->Clear(); 783 int num_targets = m_target_list.GetNumTargets(); 784 for (int i = 0; i < num_targets; i++) 785 { 786 TargetSP target_sp (m_target_list.GetTargetAtIndex (i)); 787 if (target_sp) 788 { 789 ProcessSP process_sp (target_sp->GetProcessSP()); 790 if (process_sp) 791 process_sp->Finalize(); 792 target_sp->Destroy(); 793 } 794 } 795 m_broadcaster_manager_sp->Clear (); 796 797 // Close the input file _before_ we close the input read communications class 798 // as it does NOT own the input file, our m_input_file does. 799 m_terminal_state.Clear(); 800 if (m_input_file_sp) 801 m_input_file_sp->GetFile().Close (); 802 803 m_command_interpreter_ap->Clear(); 804 }); 805 } 806 807 bool 808 Debugger::GetCloseInputOnEOF () const 809 { 810 // return m_input_comm.GetCloseOnEOF(); 811 return false; 812 } 813 814 void 815 Debugger::SetCloseInputOnEOF (bool b) 816 { 817 // m_input_comm.SetCloseOnEOF(b); 818 } 819 820 bool 821 Debugger::GetAsyncExecution () 822 { 823 return !m_command_interpreter_ap->GetSynchronous(); 824 } 825 826 void 827 Debugger::SetAsyncExecution (bool async_execution) 828 { 829 m_command_interpreter_ap->SetSynchronous (!async_execution); 830 } 831 832 void 833 Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership) 834 { 835 if (m_input_file_sp) 836 m_input_file_sp->GetFile().SetStream (fh, tranfer_ownership); 837 else 838 m_input_file_sp.reset (new StreamFile (fh, tranfer_ownership)); 839 840 File &in_file = m_input_file_sp->GetFile(); 841 if (!in_file.IsValid()) 842 in_file.SetStream (stdin, true); 843 844 // Save away the terminal state if that is relevant, so that we can restore it in RestoreInputState. 845 SaveInputTerminalState (); 846 } 847 848 void 849 Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership) 850 { 851 if (m_output_file_sp) 852 m_output_file_sp->GetFile().SetStream (fh, tranfer_ownership); 853 else 854 m_output_file_sp.reset (new StreamFile (fh, tranfer_ownership)); 855 856 File &out_file = m_output_file_sp->GetFile(); 857 if (!out_file.IsValid()) 858 out_file.SetStream (stdout, false); 859 860 // do not create the ScriptInterpreter just for setting the output file handle 861 // as the constructor will know how to do the right thing on its own 862 const bool can_create = false; 863 ScriptInterpreter* script_interpreter = GetCommandInterpreter().GetScriptInterpreter(can_create); 864 if (script_interpreter) 865 script_interpreter->ResetOutputFileHandle (fh); 866 } 867 868 void 869 Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership) 870 { 871 if (m_error_file_sp) 872 m_error_file_sp->GetFile().SetStream (fh, tranfer_ownership); 873 else 874 m_error_file_sp.reset (new StreamFile (fh, tranfer_ownership)); 875 876 File &err_file = m_error_file_sp->GetFile(); 877 if (!err_file.IsValid()) 878 err_file.SetStream (stderr, false); 879 } 880 881 void 882 Debugger::SaveInputTerminalState () 883 { 884 if (m_input_file_sp) 885 { 886 File &in_file = m_input_file_sp->GetFile(); 887 if (in_file.GetDescriptor() != File::kInvalidDescriptor) 888 m_terminal_state.Save(in_file.GetDescriptor(), true); 889 } 890 } 891 892 void 893 Debugger::RestoreInputTerminalState () 894 { 895 m_terminal_state.Restore(); 896 } 897 898 ExecutionContext 899 Debugger::GetSelectedExecutionContext () 900 { 901 ExecutionContext exe_ctx; 902 TargetSP target_sp(GetSelectedTarget()); 903 exe_ctx.SetTargetSP (target_sp); 904 905 if (target_sp) 906 { 907 ProcessSP process_sp (target_sp->GetProcessSP()); 908 exe_ctx.SetProcessSP (process_sp); 909 if (process_sp && !process_sp->IsRunning()) 910 { 911 ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread()); 912 if (thread_sp) 913 { 914 exe_ctx.SetThreadSP (thread_sp); 915 exe_ctx.SetFrameSP (thread_sp->GetSelectedFrame()); 916 if (exe_ctx.GetFramePtr() == nullptr) 917 exe_ctx.SetFrameSP (thread_sp->GetStackFrameAtIndex (0)); 918 } 919 } 920 } 921 return exe_ctx; 922 } 923 924 void 925 Debugger::DispatchInputInterrupt () 926 { 927 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 928 IOHandlerSP reader_sp (m_input_reader_stack.Top()); 929 if (reader_sp) 930 reader_sp->Interrupt(); 931 } 932 933 void 934 Debugger::DispatchInputEndOfFile () 935 { 936 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 937 IOHandlerSP reader_sp (m_input_reader_stack.Top()); 938 if (reader_sp) 939 reader_sp->GotEOF(); 940 } 941 942 void 943 Debugger::ClearIOHandlers () 944 { 945 // The bottom input reader should be the main debugger input reader. We do not want to close that one here. 946 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 947 while (m_input_reader_stack.GetSize() > 1) 948 { 949 IOHandlerSP reader_sp (m_input_reader_stack.Top()); 950 if (reader_sp) 951 PopIOHandler (reader_sp); 952 } 953 } 954 955 void 956 Debugger::ExecuteIOHandlers() 957 { 958 while (true) 959 { 960 IOHandlerSP reader_sp(m_input_reader_stack.Top()); 961 if (!reader_sp) 962 break; 963 964 reader_sp->Run(); 965 966 // Remove all input readers that are done from the top of the stack 967 while (true) 968 { 969 IOHandlerSP top_reader_sp = m_input_reader_stack.Top(); 970 if (top_reader_sp && top_reader_sp->GetIsDone()) 971 PopIOHandler (top_reader_sp); 972 else 973 break; 974 } 975 } 976 ClearIOHandlers(); 977 } 978 979 bool 980 Debugger::IsTopIOHandler (const lldb::IOHandlerSP& reader_sp) 981 { 982 return m_input_reader_stack.IsTop (reader_sp); 983 } 984 985 bool 986 Debugger::CheckTopIOHandlerTypes (IOHandler::Type top_type, IOHandler::Type second_top_type) 987 { 988 return m_input_reader_stack.CheckTopIOHandlerTypes (top_type, second_top_type); 989 } 990 991 void 992 Debugger::PrintAsync (const char *s, size_t len, bool is_stdout) 993 { 994 lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile(); 995 m_input_reader_stack.PrintAsync(stream.get(), s, len); 996 } 997 998 ConstString 999 Debugger::GetTopIOHandlerControlSequence(char ch) 1000 { 1001 return m_input_reader_stack.GetTopIOHandlerControlSequence (ch); 1002 } 1003 1004 const char * 1005 Debugger::GetIOHandlerCommandPrefix() 1006 { 1007 return m_input_reader_stack.GetTopIOHandlerCommandPrefix(); 1008 } 1009 1010 const char * 1011 Debugger::GetIOHandlerHelpPrologue() 1012 { 1013 return m_input_reader_stack.GetTopIOHandlerHelpPrologue(); 1014 } 1015 1016 void 1017 Debugger::RunIOHandler (const IOHandlerSP& reader_sp) 1018 { 1019 PushIOHandler (reader_sp); 1020 1021 IOHandlerSP top_reader_sp = reader_sp; 1022 while (top_reader_sp) 1023 { 1024 top_reader_sp->Run(); 1025 1026 if (top_reader_sp.get() == reader_sp.get()) 1027 { 1028 if (PopIOHandler (reader_sp)) 1029 break; 1030 } 1031 1032 while (true) 1033 { 1034 top_reader_sp = m_input_reader_stack.Top(); 1035 if (top_reader_sp && top_reader_sp->GetIsDone()) 1036 PopIOHandler (top_reader_sp); 1037 else 1038 break; 1039 } 1040 } 1041 } 1042 1043 void 1044 Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out, StreamFileSP &err) 1045 { 1046 // Before an IOHandler runs, it must have in/out/err streams. 1047 // This function is called when one ore more of the streams 1048 // are nullptr. We use the top input reader's in/out/err streams, 1049 // or fall back to the debugger file handles, or we fall back 1050 // onto stdin/stdout/stderr as a last resort. 1051 1052 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 1053 IOHandlerSP top_reader_sp (m_input_reader_stack.Top()); 1054 // If no STDIN has been set, then set it appropriately 1055 if (!in) 1056 { 1057 if (top_reader_sp) 1058 in = top_reader_sp->GetInputStreamFile(); 1059 else 1060 in = GetInputFile(); 1061 1062 // If there is nothing, use stdin 1063 if (!in) 1064 in = StreamFileSP(new StreamFile(stdin, false)); 1065 } 1066 // If no STDOUT has been set, then set it appropriately 1067 if (!out) 1068 { 1069 if (top_reader_sp) 1070 out = top_reader_sp->GetOutputStreamFile(); 1071 else 1072 out = GetOutputFile(); 1073 1074 // If there is nothing, use stdout 1075 if (!out) 1076 out = StreamFileSP(new StreamFile(stdout, false)); 1077 } 1078 // If no STDERR has been set, then set it appropriately 1079 if (!err) 1080 { 1081 if (top_reader_sp) 1082 err = top_reader_sp->GetErrorStreamFile(); 1083 else 1084 err = GetErrorFile(); 1085 1086 // If there is nothing, use stderr 1087 if (!err) 1088 err = StreamFileSP(new StreamFile(stdout, false)); 1089 1090 } 1091 } 1092 1093 void 1094 Debugger::PushIOHandler (const IOHandlerSP& reader_sp) 1095 { 1096 if (!reader_sp) 1097 return; 1098 1099 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 1100 1101 // Get the current top input reader... 1102 IOHandlerSP top_reader_sp (m_input_reader_stack.Top()); 1103 1104 // Don't push the same IO handler twice... 1105 if (reader_sp == top_reader_sp) 1106 return; 1107 1108 // Push our new input reader 1109 m_input_reader_stack.Push (reader_sp); 1110 reader_sp->Activate(); 1111 1112 // Interrupt the top input reader to it will exit its Run() function 1113 // and let this new input reader take over 1114 if (top_reader_sp) 1115 { 1116 top_reader_sp->Deactivate(); 1117 top_reader_sp->Cancel(); 1118 } 1119 } 1120 1121 bool 1122 Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp) 1123 { 1124 if (! pop_reader_sp) 1125 return false; 1126 1127 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 1128 1129 // The reader on the stop of the stack is done, so let the next 1130 // read on the stack refresh its prompt and if there is one... 1131 if (m_input_reader_stack.IsEmpty()) 1132 return false; 1133 1134 IOHandlerSP reader_sp(m_input_reader_stack.Top()); 1135 1136 if (pop_reader_sp != reader_sp) 1137 return false; 1138 1139 reader_sp->Deactivate(); 1140 reader_sp->Cancel(); 1141 m_input_reader_stack.Pop (); 1142 1143 reader_sp = m_input_reader_stack.Top(); 1144 if (reader_sp) 1145 reader_sp->Activate(); 1146 1147 return true; 1148 } 1149 1150 StreamSP 1151 Debugger::GetAsyncOutputStream () 1152 { 1153 return StreamSP (new StreamAsynchronousIO (*this, true)); 1154 } 1155 1156 StreamSP 1157 Debugger::GetAsyncErrorStream () 1158 { 1159 return StreamSP (new StreamAsynchronousIO (*this, false)); 1160 } 1161 1162 size_t 1163 Debugger::GetNumDebuggers() 1164 { 1165 if (lldb_initialized) 1166 { 1167 Mutex::Locker locker (GetDebuggerListMutex ()); 1168 return GetDebuggerList().size(); 1169 } 1170 return 0; 1171 } 1172 1173 lldb::DebuggerSP 1174 Debugger::GetDebuggerAtIndex (size_t index) 1175 { 1176 DebuggerSP debugger_sp; 1177 1178 if (lldb_initialized) 1179 { 1180 Mutex::Locker locker (GetDebuggerListMutex ()); 1181 DebuggerList &debugger_list = GetDebuggerList(); 1182 1183 if (index < debugger_list.size()) 1184 debugger_sp = debugger_list[index]; 1185 } 1186 1187 return debugger_sp; 1188 } 1189 1190 DebuggerSP 1191 Debugger::FindDebuggerWithID (lldb::user_id_t id) 1192 { 1193 DebuggerSP debugger_sp; 1194 1195 if (lldb_initialized) 1196 { 1197 Mutex::Locker locker (GetDebuggerListMutex ()); 1198 DebuggerList &debugger_list = GetDebuggerList(); 1199 DebuggerList::iterator pos, end = debugger_list.end(); 1200 for (pos = debugger_list.begin(); pos != end; ++pos) 1201 { 1202 if ((*pos)->GetID() == id) 1203 { 1204 debugger_sp = *pos; 1205 break; 1206 } 1207 } 1208 } 1209 return debugger_sp; 1210 } 1211 1212 #if 0 1213 static void 1214 TestPromptFormats (StackFrame *frame) 1215 { 1216 if (frame == nullptr) 1217 return; 1218 1219 StreamString s; 1220 const char *prompt_format = 1221 "{addr = '${addr}'\n}" 1222 "{addr-file-or-load = '${addr-file-or-load}'\n}" 1223 "{current-pc-arrow = '${current-pc-arrow}'\n}" 1224 "{process.id = '${process.id}'\n}" 1225 "{process.name = '${process.name}'\n}" 1226 "{process.file.basename = '${process.file.basename}'\n}" 1227 "{process.file.fullpath = '${process.file.fullpath}'\n}" 1228 "{thread.id = '${thread.id}'\n}" 1229 "{thread.index = '${thread.index}'\n}" 1230 "{thread.name = '${thread.name}'\n}" 1231 "{thread.queue = '${thread.queue}'\n}" 1232 "{thread.stop-reason = '${thread.stop-reason}'\n}" 1233 "{target.arch = '${target.arch}'\n}" 1234 "{module.file.basename = '${module.file.basename}'\n}" 1235 "{module.file.fullpath = '${module.file.fullpath}'\n}" 1236 "{file.basename = '${file.basename}'\n}" 1237 "{file.fullpath = '${file.fullpath}'\n}" 1238 "{frame.index = '${frame.index}'\n}" 1239 "{frame.pc = '${frame.pc}'\n}" 1240 "{frame.sp = '${frame.sp}'\n}" 1241 "{frame.fp = '${frame.fp}'\n}" 1242 "{frame.flags = '${frame.flags}'\n}" 1243 "{frame.reg.rdi = '${frame.reg.rdi}'\n}" 1244 "{frame.reg.rip = '${frame.reg.rip}'\n}" 1245 "{frame.reg.rsp = '${frame.reg.rsp}'\n}" 1246 "{frame.reg.rbp = '${frame.reg.rbp}'\n}" 1247 "{frame.reg.rflags = '${frame.reg.rflags}'\n}" 1248 "{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}" 1249 "{frame.reg.carp = '${frame.reg.carp}'\n}" 1250 "{function.id = '${function.id}'\n}" 1251 "{function.changed = '${function.changed}'\n}" 1252 "{function.initial-function = '${function.initial-function}'\n}" 1253 "{function.name = '${function.name}'\n}" 1254 "{function.name-without-args = '${function.name-without-args}'\n}" 1255 "{function.name-with-args = '${function.name-with-args}'\n}" 1256 "{function.addr-offset = '${function.addr-offset}'\n}" 1257 "{function.concrete-only-addr-offset-no-padding = '${function.concrete-only-addr-offset-no-padding}'\n}" 1258 "{function.line-offset = '${function.line-offset}'\n}" 1259 "{function.pc-offset = '${function.pc-offset}'\n}" 1260 "{line.file.basename = '${line.file.basename}'\n}" 1261 "{line.file.fullpath = '${line.file.fullpath}'\n}" 1262 "{line.number = '${line.number}'\n}" 1263 "{line.start-addr = '${line.start-addr}'\n}" 1264 "{line.end-addr = '${line.end-addr}'\n}" 1265 ; 1266 1267 SymbolContext sc (frame->GetSymbolContext(eSymbolContextEverything)); 1268 ExecutionContext exe_ctx; 1269 frame->CalculateExecutionContext(exe_ctx); 1270 if (Debugger::FormatPrompt (prompt_format, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s)) 1271 { 1272 printf("%s\n", s.GetData()); 1273 } 1274 else 1275 { 1276 printf ("what we got: %s\n", s.GetData()); 1277 } 1278 } 1279 #endif 1280 1281 bool 1282 Debugger::FormatDisassemblerAddress (const FormatEntity::Entry *format, 1283 const SymbolContext *sc, 1284 const SymbolContext *prev_sc, 1285 const ExecutionContext *exe_ctx, 1286 const Address *addr, 1287 Stream &s) 1288 { 1289 FormatEntity::Entry format_entry; 1290 1291 if (format == nullptr) 1292 { 1293 if (exe_ctx != nullptr && exe_ctx->HasTargetScope()) 1294 format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat(); 1295 if (format == nullptr) 1296 { 1297 FormatEntity::Parse("${addr}: ", format_entry); 1298 format = &format_entry; 1299 } 1300 } 1301 bool function_changed = false; 1302 bool initial_function = false; 1303 if (prev_sc && (prev_sc->function || prev_sc->symbol)) 1304 { 1305 if (sc && (sc->function || sc->symbol)) 1306 { 1307 if (prev_sc->symbol && sc->symbol) 1308 { 1309 if (!sc->symbol->Compare (prev_sc->symbol->GetName(), prev_sc->symbol->GetType())) 1310 { 1311 function_changed = true; 1312 } 1313 } 1314 else if (prev_sc->function && sc->function) 1315 { 1316 if (prev_sc->function->GetMangled() != sc->function->GetMangled()) 1317 { 1318 function_changed = true; 1319 } 1320 } 1321 } 1322 } 1323 // The first context on a list of instructions will have a prev_sc that 1324 // has no Function or Symbol -- if SymbolContext had an IsValid() method, it 1325 // would return false. But we do get a prev_sc pointer. 1326 if ((sc && (sc->function || sc->symbol)) 1327 && prev_sc && (prev_sc->function == nullptr && prev_sc->symbol == nullptr)) 1328 { 1329 initial_function = true; 1330 } 1331 return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr, function_changed, initial_function); 1332 } 1333 1334 void 1335 Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1336 { 1337 // For simplicity's sake, I am not going to deal with how to close down any 1338 // open logging streams, I just redirect everything from here on out to the 1339 // callback. 1340 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton)); 1341 } 1342 1343 bool 1344 Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream) 1345 { 1346 StreamSP log_stream_sp; 1347 if (m_log_callback_stream_sp) 1348 { 1349 log_stream_sp = m_log_callback_stream_sp; 1350 // For now when using the callback mode you always get thread & timestamp. 1351 log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1352 } 1353 else if (log_file == nullptr || *log_file == '\0') 1354 { 1355 log_stream_sp = GetOutputFile(); 1356 } 1357 else 1358 { 1359 LogStreamMap::iterator pos = m_log_streams.find(log_file); 1360 if (pos != m_log_streams.end()) 1361 log_stream_sp = pos->second.lock(); 1362 if (!log_stream_sp) 1363 { 1364 uint32_t options = File::eOpenOptionWrite | File::eOpenOptionCanCreate 1365 | File::eOpenOptionCloseOnExec | File::eOpenOptionAppend; 1366 if (! (log_options & LLDB_LOG_OPTION_APPEND)) 1367 options |= File::eOpenOptionTruncate; 1368 1369 log_stream_sp.reset (new StreamFile (log_file, options)); 1370 m_log_streams[log_file] = log_stream_sp; 1371 } 1372 } 1373 assert(log_stream_sp); 1374 1375 if (log_options == 0) 1376 log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE; 1377 1378 return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories, error_stream); 1379 } 1380 1381 SourceManager & 1382 Debugger::GetSourceManager () 1383 { 1384 if (!m_source_manager_ap) 1385 m_source_manager_ap.reset (new SourceManager (shared_from_this())); 1386 return *m_source_manager_ap; 1387 } 1388 1389 // This function handles events that were broadcast by the process. 1390 void 1391 Debugger::HandleBreakpointEvent (const EventSP &event_sp) 1392 { 1393 using namespace lldb; 1394 const uint32_t event_type = Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (event_sp); 1395 1396 // if (event_type & eBreakpointEventTypeAdded 1397 // || event_type & eBreakpointEventTypeRemoved 1398 // || event_type & eBreakpointEventTypeEnabled 1399 // || event_type & eBreakpointEventTypeDisabled 1400 // || event_type & eBreakpointEventTypeCommandChanged 1401 // || event_type & eBreakpointEventTypeConditionChanged 1402 // || event_type & eBreakpointEventTypeIgnoreChanged 1403 // || event_type & eBreakpointEventTypeLocationsResolved) 1404 // { 1405 // // Don't do anything about these events, since the breakpoint commands already echo these actions. 1406 // } 1407 // 1408 if (event_type & eBreakpointEventTypeLocationsAdded) 1409 { 1410 uint32_t num_new_locations = Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(event_sp); 1411 if (num_new_locations > 0) 1412 { 1413 BreakpointSP breakpoint = Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp); 1414 StreamSP output_sp (GetAsyncOutputStream()); 1415 if (output_sp) 1416 { 1417 output_sp->Printf("%d location%s added to breakpoint %d\n", 1418 num_new_locations, 1419 num_new_locations == 1 ? "" : "s", 1420 breakpoint->GetID()); 1421 output_sp->Flush(); 1422 } 1423 } 1424 } 1425 // else if (event_type & eBreakpointEventTypeLocationsRemoved) 1426 // { 1427 // // These locations just get disabled, not sure it is worth spamming folks about this on the command line. 1428 // } 1429 // else if (event_type & eBreakpointEventTypeLocationsResolved) 1430 // { 1431 // // This might be an interesting thing to note, but I'm going to leave it quiet for now, it just looked noisy. 1432 // } 1433 } 1434 1435 size_t 1436 Debugger::GetProcessSTDOUT (Process *process, Stream *stream) 1437 { 1438 size_t total_bytes = 0; 1439 if (stream == nullptr) 1440 stream = GetOutputFile().get(); 1441 1442 if (stream) 1443 { 1444 // The process has stuff waiting for stdout; get it and write it out to the appropriate place. 1445 if (process == nullptr) 1446 { 1447 TargetSP target_sp = GetTargetList().GetSelectedTarget(); 1448 if (target_sp) 1449 process = target_sp->GetProcessSP().get(); 1450 } 1451 if (process) 1452 { 1453 Error error; 1454 size_t len; 1455 char stdio_buffer[1024]; 1456 while ((len = process->GetSTDOUT (stdio_buffer, sizeof (stdio_buffer), error)) > 0) 1457 { 1458 stream->Write(stdio_buffer, len); 1459 total_bytes += len; 1460 } 1461 } 1462 stream->Flush(); 1463 } 1464 return total_bytes; 1465 } 1466 1467 size_t 1468 Debugger::GetProcessSTDERR (Process *process, Stream *stream) 1469 { 1470 size_t total_bytes = 0; 1471 if (stream == nullptr) 1472 stream = GetOutputFile().get(); 1473 1474 if (stream) 1475 { 1476 // The process has stuff waiting for stderr; get it and write it out to the appropriate place. 1477 if (process == nullptr) 1478 { 1479 TargetSP target_sp = GetTargetList().GetSelectedTarget(); 1480 if (target_sp) 1481 process = target_sp->GetProcessSP().get(); 1482 } 1483 if (process) 1484 { 1485 Error error; 1486 size_t len; 1487 char stdio_buffer[1024]; 1488 while ((len = process->GetSTDERR (stdio_buffer, sizeof (stdio_buffer), error)) > 0) 1489 { 1490 stream->Write(stdio_buffer, len); 1491 total_bytes += len; 1492 } 1493 } 1494 stream->Flush(); 1495 } 1496 return total_bytes; 1497 } 1498 1499 1500 // This function handles events that were broadcast by the process. 1501 void 1502 Debugger::HandleProcessEvent (const EventSP &event_sp) 1503 { 1504 using namespace lldb; 1505 const uint32_t event_type = event_sp->GetType(); 1506 ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get()); 1507 1508 StreamSP output_stream_sp = GetAsyncOutputStream(); 1509 StreamSP error_stream_sp = GetAsyncErrorStream(); 1510 const bool gui_enabled = IsForwardingEvents(); 1511 1512 if (!gui_enabled) 1513 { 1514 bool pop_process_io_handler = false; 1515 assert (process_sp); 1516 1517 bool state_is_stopped = false; 1518 const bool got_state_changed = (event_type & Process::eBroadcastBitStateChanged) != 0; 1519 const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0; 1520 const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0; 1521 if (got_state_changed) 1522 { 1523 StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get()); 1524 state_is_stopped = StateIsStoppedState(event_state, false); 1525 } 1526 1527 // Display running state changes first before any STDIO 1528 if (got_state_changed && !state_is_stopped) 1529 { 1530 Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler); 1531 } 1532 1533 // Now display and STDOUT 1534 if (got_stdout || got_state_changed) 1535 { 1536 GetProcessSTDOUT (process_sp.get(), output_stream_sp.get()); 1537 } 1538 1539 // Now display and STDERR 1540 if (got_stderr || got_state_changed) 1541 { 1542 GetProcessSTDERR (process_sp.get(), error_stream_sp.get()); 1543 } 1544 1545 // Now display any stopped state changes after any STDIO 1546 if (got_state_changed && state_is_stopped) 1547 { 1548 Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler); 1549 } 1550 1551 output_stream_sp->Flush(); 1552 error_stream_sp->Flush(); 1553 1554 if (pop_process_io_handler) 1555 process_sp->PopProcessIOHandler(); 1556 } 1557 } 1558 1559 void 1560 Debugger::HandleThreadEvent (const EventSP &event_sp) 1561 { 1562 // At present the only thread event we handle is the Frame Changed event, 1563 // and all we do for that is just reprint the thread status for that thread. 1564 using namespace lldb; 1565 const uint32_t event_type = event_sp->GetType(); 1566 if (event_type == Thread::eBroadcastBitStackChanged || 1567 event_type == Thread::eBroadcastBitThreadSelected ) 1568 { 1569 ThreadSP thread_sp (Thread::ThreadEventData::GetThreadFromEvent (event_sp.get())); 1570 if (thread_sp) 1571 { 1572 thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1); 1573 } 1574 } 1575 } 1576 1577 bool 1578 Debugger::IsForwardingEvents () 1579 { 1580 return (bool)m_forward_listener_sp; 1581 } 1582 1583 void 1584 Debugger::EnableForwardEvents (const ListenerSP &listener_sp) 1585 { 1586 m_forward_listener_sp = listener_sp; 1587 } 1588 1589 void 1590 Debugger::CancelForwardEvents (const ListenerSP &listener_sp) 1591 { 1592 m_forward_listener_sp.reset(); 1593 } 1594 1595 1596 void 1597 Debugger::DefaultEventHandler() 1598 { 1599 ListenerSP listener_sp(GetListener()); 1600 ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass()); 1601 ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass()); 1602 ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass()); 1603 BroadcastEventSpec target_event_spec (broadcaster_class_target, 1604 Target::eBroadcastBitBreakpointChanged); 1605 1606 BroadcastEventSpec process_event_spec (broadcaster_class_process, 1607 Process::eBroadcastBitStateChanged | 1608 Process::eBroadcastBitSTDOUT | 1609 Process::eBroadcastBitSTDERR); 1610 1611 BroadcastEventSpec thread_event_spec (broadcaster_class_thread, 1612 Thread::eBroadcastBitStackChanged | 1613 Thread::eBroadcastBitThreadSelected ); 1614 1615 listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, target_event_spec); 1616 listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, process_event_spec); 1617 listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, thread_event_spec); 1618 listener_sp->StartListeningForEvents (m_command_interpreter_ap.get(), 1619 CommandInterpreter::eBroadcastBitQuitCommandReceived | 1620 CommandInterpreter::eBroadcastBitAsynchronousOutputData | 1621 CommandInterpreter::eBroadcastBitAsynchronousErrorData ); 1622 1623 // Let the thread that spawned us know that we have started up and 1624 // that we are now listening to all required events so no events get missed 1625 m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening); 1626 1627 bool done = false; 1628 while (!done) 1629 { 1630 EventSP event_sp; 1631 if (listener_sp->WaitForEvent(nullptr, event_sp)) 1632 { 1633 if (event_sp) 1634 { 1635 Broadcaster *broadcaster = event_sp->GetBroadcaster(); 1636 if (broadcaster) 1637 { 1638 uint32_t event_type = event_sp->GetType(); 1639 ConstString broadcaster_class (broadcaster->GetBroadcasterClass()); 1640 if (broadcaster_class == broadcaster_class_process) 1641 { 1642 HandleProcessEvent (event_sp); 1643 } 1644 else if (broadcaster_class == broadcaster_class_target) 1645 { 1646 if (Breakpoint::BreakpointEventData::GetEventDataFromEvent(event_sp.get())) 1647 { 1648 HandleBreakpointEvent (event_sp); 1649 } 1650 } 1651 else if (broadcaster_class == broadcaster_class_thread) 1652 { 1653 HandleThreadEvent (event_sp); 1654 } 1655 else if (broadcaster == m_command_interpreter_ap.get()) 1656 { 1657 if (event_type & CommandInterpreter::eBroadcastBitQuitCommandReceived) 1658 { 1659 done = true; 1660 } 1661 else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousErrorData) 1662 { 1663 const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get())); 1664 if (data && data[0]) 1665 { 1666 StreamSP error_sp (GetAsyncErrorStream()); 1667 if (error_sp) 1668 { 1669 error_sp->PutCString(data); 1670 error_sp->Flush(); 1671 } 1672 } 1673 } 1674 else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousOutputData) 1675 { 1676 const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get())); 1677 if (data && data[0]) 1678 { 1679 StreamSP output_sp (GetAsyncOutputStream()); 1680 if (output_sp) 1681 { 1682 output_sp->PutCString(data); 1683 output_sp->Flush(); 1684 } 1685 } 1686 } 1687 } 1688 } 1689 1690 if (m_forward_listener_sp) 1691 m_forward_listener_sp->AddEvent(event_sp); 1692 } 1693 } 1694 } 1695 } 1696 1697 lldb::thread_result_t 1698 Debugger::EventHandlerThread (lldb::thread_arg_t arg) 1699 { 1700 ((Debugger *)arg)->DefaultEventHandler(); 1701 return NULL; 1702 } 1703 1704 bool 1705 Debugger::StartEventHandlerThread() 1706 { 1707 if (!m_event_handler_thread.IsJoinable()) 1708 { 1709 // We must synchronize with the DefaultEventHandler() thread to ensure 1710 // it is up and running and listening to events before we return from 1711 // this function. We do this by listening to events for the 1712 // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster 1713 ListenerSP listener_sp(Listener::MakeListener("lldb.debugger.event-handler")); 1714 listener_sp->StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening); 1715 1716 // Use larger 8MB stack for this thread 1717 m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler", 1718 EventHandlerThread, 1719 this, 1720 nullptr, 1721 g_debugger_event_thread_stack_bytes); 1722 1723 // Make sure DefaultEventHandler() is running and listening to events before we return 1724 // from this function. We are only listening for events of type 1725 // eBroadcastBitEventThreadIsListening so we don't need to check the event, we just need 1726 // to wait an infinite amount of time for it (nullptr timeout as the first parameter) 1727 lldb::EventSP event_sp; 1728 listener_sp->WaitForEvent(nullptr, event_sp); 1729 } 1730 return m_event_handler_thread.IsJoinable(); 1731 } 1732 1733 void 1734 Debugger::StopEventHandlerThread() 1735 { 1736 if (m_event_handler_thread.IsJoinable()) 1737 { 1738 GetCommandInterpreter().BroadcastEvent(CommandInterpreter::eBroadcastBitQuitCommandReceived); 1739 m_event_handler_thread.Join(nullptr); 1740 } 1741 } 1742 1743 lldb::thread_result_t 1744 Debugger::IOHandlerThread (lldb::thread_arg_t arg) 1745 { 1746 Debugger *debugger = (Debugger *)arg; 1747 debugger->ExecuteIOHandlers(); 1748 debugger->StopEventHandlerThread(); 1749 return NULL; 1750 } 1751 1752 bool 1753 Debugger::HasIOHandlerThread() 1754 { 1755 return m_io_handler_thread.IsJoinable(); 1756 } 1757 1758 bool 1759 Debugger::StartIOHandlerThread() 1760 { 1761 if (!m_io_handler_thread.IsJoinable()) 1762 m_io_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.io-handler", 1763 IOHandlerThread, 1764 this, 1765 nullptr, 1766 8*1024*1024); // Use larger 8MB stack for this thread 1767 return m_io_handler_thread.IsJoinable(); 1768 } 1769 1770 void 1771 Debugger::StopIOHandlerThread() 1772 { 1773 if (m_io_handler_thread.IsJoinable()) 1774 { 1775 if (m_input_file_sp) 1776 m_input_file_sp->GetFile().Close(); 1777 m_io_handler_thread.Join(nullptr); 1778 } 1779 } 1780 1781 void 1782 Debugger::JoinIOHandlerThread() 1783 { 1784 if (HasIOHandlerThread()) 1785 { 1786 thread_result_t result; 1787 m_io_handler_thread.Join(&result); 1788 m_io_handler_thread = LLDB_INVALID_HOST_THREAD; 1789 } 1790 } 1791 1792 Target * 1793 Debugger::GetDummyTarget() 1794 { 1795 return m_target_list.GetDummyTarget (*this).get(); 1796 } 1797 1798 Target * 1799 Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) 1800 { 1801 Target *target = nullptr; 1802 if (!prefer_dummy) 1803 { 1804 target = m_target_list.GetSelectedTarget().get(); 1805 if (target) 1806 return target; 1807 } 1808 1809 return GetDummyTarget(); 1810 } 1811 1812 Error 1813 Debugger::RunREPL (LanguageType language, const char *repl_options) 1814 { 1815 Error err; 1816 FileSpec repl_executable; 1817 1818 if (language == eLanguageTypeUnknown) 1819 { 1820 std::set<LanguageType> repl_languages; 1821 1822 Language::GetLanguagesSupportingREPLs(repl_languages); 1823 1824 if (repl_languages.size() == 1) 1825 { 1826 language = *repl_languages.begin(); 1827 } 1828 else if (repl_languages.empty()) 1829 { 1830 err.SetErrorStringWithFormat("LLDB isn't configured with REPL support for any languages."); 1831 return err; 1832 } 1833 else 1834 { 1835 err.SetErrorStringWithFormat("Multiple possible REPL languages. Please specify a language."); 1836 return err; 1837 } 1838 } 1839 1840 Target *const target = nullptr; // passing in an empty target means the REPL must create one 1841 1842 REPLSP repl_sp(REPL::Create(err, language, this, target, repl_options)); 1843 1844 if (!err.Success()) 1845 { 1846 return err; 1847 } 1848 1849 if (!repl_sp) 1850 { 1851 err.SetErrorStringWithFormat("couldn't find a REPL for %s", Language::GetNameForLanguageType(language)); 1852 return err; 1853 } 1854 1855 repl_sp->SetCompilerOptions(repl_options); 1856 repl_sp->RunLoop(); 1857 1858 return err; 1859 } 1860