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_terminal_state(), 706 m_target_list(*this), 707 m_platform_list(), 708 m_listener("lldb.Debugger"), 709 m_source_manager_ap(), 710 m_source_file_cache(), 711 m_command_interpreter_ap(new CommandInterpreter(*this, eScriptLanguageDefault, false)), 712 m_input_reader_stack(), 713 m_instance_name(), 714 m_loaded_plugins(), 715 m_event_handler_thread(), 716 m_io_handler_thread(), 717 m_sync_broadcaster(nullptr, "lldb.debugger.sync") 718 { 719 char instance_cstr[256]; 720 snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID()); 721 m_instance_name.SetCString(instance_cstr); 722 if (log_callback) 723 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton)); 724 m_command_interpreter_ap->Initialize (); 725 // Always add our default platform to the platform list 726 PlatformSP default_platform_sp (Platform::GetHostPlatform()); 727 assert(default_platform_sp); 728 m_platform_list.Append (default_platform_sp, true); 729 730 m_collection_sp->Initialize (g_properties); 731 m_collection_sp->AppendProperty (ConstString("target"), 732 ConstString("Settings specify to debugging targets."), 733 true, 734 Target::GetGlobalProperties()->GetValueProperties()); 735 m_collection_sp->AppendProperty (ConstString("platform"), 736 ConstString("Platform settings."), 737 true, 738 Platform::GetGlobalPlatformProperties()->GetValueProperties()); 739 if (m_command_interpreter_ap) 740 { 741 m_collection_sp->AppendProperty (ConstString("interpreter"), 742 ConstString("Settings specify to the debugger's command interpreter."), 743 true, 744 m_command_interpreter_ap->GetValueProperties()); 745 } 746 OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(nullptr, ePropertyTerminalWidth); 747 term_width->SetMinimumValue(10); 748 term_width->SetMaximumValue(1024); 749 750 // Turn off use-color if this is a dumb terminal. 751 const char *term = getenv ("TERM"); 752 if (term && !strcmp (term, "dumb")) 753 SetUseColor (false); 754 } 755 756 Debugger::~Debugger () 757 { 758 Clear(); 759 } 760 761 void 762 Debugger::Clear() 763 { 764 ClearIOHandlers(); 765 StopIOHandlerThread(); 766 StopEventHandlerThread(); 767 m_listener.Clear(); 768 int num_targets = m_target_list.GetNumTargets(); 769 for (int i = 0; i < num_targets; i++) 770 { 771 TargetSP target_sp (m_target_list.GetTargetAtIndex (i)); 772 if (target_sp) 773 { 774 ProcessSP process_sp (target_sp->GetProcessSP()); 775 if (process_sp) 776 process_sp->Finalize(); 777 target_sp->Destroy(); 778 } 779 } 780 BroadcasterManager::Clear (); 781 782 // Close the input file _before_ we close the input read communications class 783 // as it does NOT own the input file, our m_input_file does. 784 m_terminal_state.Clear(); 785 if (m_input_file_sp) 786 m_input_file_sp->GetFile().Close (); 787 788 m_command_interpreter_ap->Clear(); 789 } 790 791 bool 792 Debugger::GetCloseInputOnEOF () const 793 { 794 // return m_input_comm.GetCloseOnEOF(); 795 return false; 796 } 797 798 void 799 Debugger::SetCloseInputOnEOF (bool b) 800 { 801 // m_input_comm.SetCloseOnEOF(b); 802 } 803 804 bool 805 Debugger::GetAsyncExecution () 806 { 807 return !m_command_interpreter_ap->GetSynchronous(); 808 } 809 810 void 811 Debugger::SetAsyncExecution (bool async_execution) 812 { 813 m_command_interpreter_ap->SetSynchronous (!async_execution); 814 } 815 816 void 817 Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership) 818 { 819 if (m_input_file_sp) 820 m_input_file_sp->GetFile().SetStream (fh, tranfer_ownership); 821 else 822 m_input_file_sp.reset (new StreamFile (fh, tranfer_ownership)); 823 824 File &in_file = m_input_file_sp->GetFile(); 825 if (!in_file.IsValid()) 826 in_file.SetStream (stdin, true); 827 828 // Save away the terminal state if that is relevant, so that we can restore it in RestoreInputState. 829 SaveInputTerminalState (); 830 } 831 832 void 833 Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership) 834 { 835 if (m_output_file_sp) 836 m_output_file_sp->GetFile().SetStream (fh, tranfer_ownership); 837 else 838 m_output_file_sp.reset (new StreamFile (fh, tranfer_ownership)); 839 840 File &out_file = m_output_file_sp->GetFile(); 841 if (!out_file.IsValid()) 842 out_file.SetStream (stdout, false); 843 844 // do not create the ScriptInterpreter just for setting the output file handle 845 // as the constructor will know how to do the right thing on its own 846 const bool can_create = false; 847 ScriptInterpreter* script_interpreter = GetCommandInterpreter().GetScriptInterpreter(can_create); 848 if (script_interpreter) 849 script_interpreter->ResetOutputFileHandle (fh); 850 } 851 852 void 853 Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership) 854 { 855 if (m_error_file_sp) 856 m_error_file_sp->GetFile().SetStream (fh, tranfer_ownership); 857 else 858 m_error_file_sp.reset (new StreamFile (fh, tranfer_ownership)); 859 860 File &err_file = m_error_file_sp->GetFile(); 861 if (!err_file.IsValid()) 862 err_file.SetStream (stderr, false); 863 } 864 865 void 866 Debugger::SaveInputTerminalState () 867 { 868 if (m_input_file_sp) 869 { 870 File &in_file = m_input_file_sp->GetFile(); 871 if (in_file.GetDescriptor() != File::kInvalidDescriptor) 872 m_terminal_state.Save(in_file.GetDescriptor(), true); 873 } 874 } 875 876 void 877 Debugger::RestoreInputTerminalState () 878 { 879 m_terminal_state.Restore(); 880 } 881 882 ExecutionContext 883 Debugger::GetSelectedExecutionContext () 884 { 885 ExecutionContext exe_ctx; 886 TargetSP target_sp(GetSelectedTarget()); 887 exe_ctx.SetTargetSP (target_sp); 888 889 if (target_sp) 890 { 891 ProcessSP process_sp (target_sp->GetProcessSP()); 892 exe_ctx.SetProcessSP (process_sp); 893 if (process_sp && !process_sp->IsRunning()) 894 { 895 ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread()); 896 if (thread_sp) 897 { 898 exe_ctx.SetThreadSP (thread_sp); 899 exe_ctx.SetFrameSP (thread_sp->GetSelectedFrame()); 900 if (exe_ctx.GetFramePtr() == nullptr) 901 exe_ctx.SetFrameSP (thread_sp->GetStackFrameAtIndex (0)); 902 } 903 } 904 } 905 return exe_ctx; 906 } 907 908 void 909 Debugger::DispatchInputInterrupt () 910 { 911 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 912 IOHandlerSP reader_sp (m_input_reader_stack.Top()); 913 if (reader_sp) 914 reader_sp->Interrupt(); 915 } 916 917 void 918 Debugger::DispatchInputEndOfFile () 919 { 920 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 921 IOHandlerSP reader_sp (m_input_reader_stack.Top()); 922 if (reader_sp) 923 reader_sp->GotEOF(); 924 } 925 926 void 927 Debugger::ClearIOHandlers () 928 { 929 // The bottom input reader should be the main debugger input reader. We do not want to close that one here. 930 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 931 while (m_input_reader_stack.GetSize() > 1) 932 { 933 IOHandlerSP reader_sp (m_input_reader_stack.Top()); 934 if (reader_sp) 935 PopIOHandler (reader_sp); 936 } 937 } 938 939 void 940 Debugger::ExecuteIOHandlers() 941 { 942 while (true) 943 { 944 IOHandlerSP reader_sp(m_input_reader_stack.Top()); 945 if (!reader_sp) 946 break; 947 948 reader_sp->Run(); 949 950 // Remove all input readers that are done from the top of the stack 951 while (true) 952 { 953 IOHandlerSP top_reader_sp = m_input_reader_stack.Top(); 954 if (top_reader_sp && top_reader_sp->GetIsDone()) 955 PopIOHandler (top_reader_sp); 956 else 957 break; 958 } 959 } 960 ClearIOHandlers(); 961 } 962 963 bool 964 Debugger::IsTopIOHandler (const lldb::IOHandlerSP& reader_sp) 965 { 966 return m_input_reader_stack.IsTop (reader_sp); 967 } 968 969 bool 970 Debugger::CheckTopIOHandlerTypes (IOHandler::Type top_type, IOHandler::Type second_top_type) 971 { 972 return m_input_reader_stack.CheckTopIOHandlerTypes (top_type, second_top_type); 973 } 974 975 void 976 Debugger::PrintAsync (const char *s, size_t len, bool is_stdout) 977 { 978 lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile(); 979 m_input_reader_stack.PrintAsync(stream.get(), s, len); 980 } 981 982 ConstString 983 Debugger::GetTopIOHandlerControlSequence(char ch) 984 { 985 return m_input_reader_stack.GetTopIOHandlerControlSequence (ch); 986 } 987 988 const char * 989 Debugger::GetIOHandlerCommandPrefix() 990 { 991 return m_input_reader_stack.GetTopIOHandlerCommandPrefix(); 992 } 993 994 const char * 995 Debugger::GetIOHandlerHelpPrologue() 996 { 997 return m_input_reader_stack.GetTopIOHandlerHelpPrologue(); 998 } 999 1000 void 1001 Debugger::RunIOHandler (const IOHandlerSP& reader_sp) 1002 { 1003 PushIOHandler (reader_sp); 1004 1005 IOHandlerSP top_reader_sp = reader_sp; 1006 while (top_reader_sp) 1007 { 1008 top_reader_sp->Run(); 1009 1010 if (top_reader_sp.get() == reader_sp.get()) 1011 { 1012 if (PopIOHandler (reader_sp)) 1013 break; 1014 } 1015 1016 while (true) 1017 { 1018 top_reader_sp = m_input_reader_stack.Top(); 1019 if (top_reader_sp && top_reader_sp->GetIsDone()) 1020 PopIOHandler (top_reader_sp); 1021 else 1022 break; 1023 } 1024 } 1025 } 1026 1027 void 1028 Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out, StreamFileSP &err) 1029 { 1030 // Before an IOHandler runs, it must have in/out/err streams. 1031 // This function is called when one ore more of the streams 1032 // are nullptr. We use the top input reader's in/out/err streams, 1033 // or fall back to the debugger file handles, or we fall back 1034 // onto stdin/stdout/stderr as a last resort. 1035 1036 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 1037 IOHandlerSP top_reader_sp (m_input_reader_stack.Top()); 1038 // If no STDIN has been set, then set it appropriately 1039 if (!in) 1040 { 1041 if (top_reader_sp) 1042 in = top_reader_sp->GetInputStreamFile(); 1043 else 1044 in = GetInputFile(); 1045 1046 // If there is nothing, use stdin 1047 if (!in) 1048 in = StreamFileSP(new StreamFile(stdin, false)); 1049 } 1050 // If no STDOUT has been set, then set it appropriately 1051 if (!out) 1052 { 1053 if (top_reader_sp) 1054 out = top_reader_sp->GetOutputStreamFile(); 1055 else 1056 out = GetOutputFile(); 1057 1058 // If there is nothing, use stdout 1059 if (!out) 1060 out = StreamFileSP(new StreamFile(stdout, false)); 1061 } 1062 // If no STDERR has been set, then set it appropriately 1063 if (!err) 1064 { 1065 if (top_reader_sp) 1066 err = top_reader_sp->GetErrorStreamFile(); 1067 else 1068 err = GetErrorFile(); 1069 1070 // If there is nothing, use stderr 1071 if (!err) 1072 err = StreamFileSP(new StreamFile(stdout, false)); 1073 1074 } 1075 } 1076 1077 void 1078 Debugger::PushIOHandler (const IOHandlerSP& reader_sp) 1079 { 1080 if (!reader_sp) 1081 return; 1082 1083 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 1084 1085 // Get the current top input reader... 1086 IOHandlerSP top_reader_sp (m_input_reader_stack.Top()); 1087 1088 // Don't push the same IO handler twice... 1089 if (reader_sp == top_reader_sp) 1090 return; 1091 1092 // Push our new input reader 1093 m_input_reader_stack.Push (reader_sp); 1094 reader_sp->Activate(); 1095 1096 // Interrupt the top input reader to it will exit its Run() function 1097 // and let this new input reader take over 1098 if (top_reader_sp) 1099 { 1100 top_reader_sp->Deactivate(); 1101 top_reader_sp->Cancel(); 1102 } 1103 } 1104 1105 bool 1106 Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp) 1107 { 1108 if (! pop_reader_sp) 1109 return false; 1110 1111 Mutex::Locker locker (m_input_reader_stack.GetMutex()); 1112 1113 // The reader on the stop of the stack is done, so let the next 1114 // read on the stack refresh its prompt and if there is one... 1115 if (m_input_reader_stack.IsEmpty()) 1116 return false; 1117 1118 IOHandlerSP reader_sp(m_input_reader_stack.Top()); 1119 1120 if (pop_reader_sp != reader_sp) 1121 return false; 1122 1123 reader_sp->Deactivate(); 1124 reader_sp->Cancel(); 1125 m_input_reader_stack.Pop (); 1126 1127 reader_sp = m_input_reader_stack.Top(); 1128 if (reader_sp) 1129 reader_sp->Activate(); 1130 1131 return true; 1132 } 1133 1134 StreamSP 1135 Debugger::GetAsyncOutputStream () 1136 { 1137 return StreamSP (new StreamAsynchronousIO (*this, true)); 1138 } 1139 1140 StreamSP 1141 Debugger::GetAsyncErrorStream () 1142 { 1143 return StreamSP (new StreamAsynchronousIO (*this, false)); 1144 } 1145 1146 size_t 1147 Debugger::GetNumDebuggers() 1148 { 1149 if (lldb_initialized) 1150 { 1151 Mutex::Locker locker (GetDebuggerListMutex ()); 1152 return GetDebuggerList().size(); 1153 } 1154 return 0; 1155 } 1156 1157 lldb::DebuggerSP 1158 Debugger::GetDebuggerAtIndex (size_t index) 1159 { 1160 DebuggerSP debugger_sp; 1161 1162 if (lldb_initialized) 1163 { 1164 Mutex::Locker locker (GetDebuggerListMutex ()); 1165 DebuggerList &debugger_list = GetDebuggerList(); 1166 1167 if (index < debugger_list.size()) 1168 debugger_sp = debugger_list[index]; 1169 } 1170 1171 return debugger_sp; 1172 } 1173 1174 DebuggerSP 1175 Debugger::FindDebuggerWithID (lldb::user_id_t id) 1176 { 1177 DebuggerSP debugger_sp; 1178 1179 if (lldb_initialized) 1180 { 1181 Mutex::Locker locker (GetDebuggerListMutex ()); 1182 DebuggerList &debugger_list = GetDebuggerList(); 1183 DebuggerList::iterator pos, end = debugger_list.end(); 1184 for (pos = debugger_list.begin(); pos != end; ++pos) 1185 { 1186 if ((*pos)->GetID() == id) 1187 { 1188 debugger_sp = *pos; 1189 break; 1190 } 1191 } 1192 } 1193 return debugger_sp; 1194 } 1195 1196 #if 0 1197 static void 1198 TestPromptFormats (StackFrame *frame) 1199 { 1200 if (frame == nullptr) 1201 return; 1202 1203 StreamString s; 1204 const char *prompt_format = 1205 "{addr = '${addr}'\n}" 1206 "{addr-file-or-load = '${addr-file-or-load}'\n}" 1207 "{current-pc-arrow = '${current-pc-arrow}'\n}" 1208 "{process.id = '${process.id}'\n}" 1209 "{process.name = '${process.name}'\n}" 1210 "{process.file.basename = '${process.file.basename}'\n}" 1211 "{process.file.fullpath = '${process.file.fullpath}'\n}" 1212 "{thread.id = '${thread.id}'\n}" 1213 "{thread.index = '${thread.index}'\n}" 1214 "{thread.name = '${thread.name}'\n}" 1215 "{thread.queue = '${thread.queue}'\n}" 1216 "{thread.stop-reason = '${thread.stop-reason}'\n}" 1217 "{target.arch = '${target.arch}'\n}" 1218 "{module.file.basename = '${module.file.basename}'\n}" 1219 "{module.file.fullpath = '${module.file.fullpath}'\n}" 1220 "{file.basename = '${file.basename}'\n}" 1221 "{file.fullpath = '${file.fullpath}'\n}" 1222 "{frame.index = '${frame.index}'\n}" 1223 "{frame.pc = '${frame.pc}'\n}" 1224 "{frame.sp = '${frame.sp}'\n}" 1225 "{frame.fp = '${frame.fp}'\n}" 1226 "{frame.flags = '${frame.flags}'\n}" 1227 "{frame.reg.rdi = '${frame.reg.rdi}'\n}" 1228 "{frame.reg.rip = '${frame.reg.rip}'\n}" 1229 "{frame.reg.rsp = '${frame.reg.rsp}'\n}" 1230 "{frame.reg.rbp = '${frame.reg.rbp}'\n}" 1231 "{frame.reg.rflags = '${frame.reg.rflags}'\n}" 1232 "{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}" 1233 "{frame.reg.carp = '${frame.reg.carp}'\n}" 1234 "{function.id = '${function.id}'\n}" 1235 "{function.changed = '${function.changed}'\n}" 1236 "{function.initial-function = '${function.initial-function}'\n}" 1237 "{function.name = '${function.name}'\n}" 1238 "{function.name-without-args = '${function.name-without-args}'\n}" 1239 "{function.name-with-args = '${function.name-with-args}'\n}" 1240 "{function.addr-offset = '${function.addr-offset}'\n}" 1241 "{function.concrete-only-addr-offset-no-padding = '${function.concrete-only-addr-offset-no-padding}'\n}" 1242 "{function.line-offset = '${function.line-offset}'\n}" 1243 "{function.pc-offset = '${function.pc-offset}'\n}" 1244 "{line.file.basename = '${line.file.basename}'\n}" 1245 "{line.file.fullpath = '${line.file.fullpath}'\n}" 1246 "{line.number = '${line.number}'\n}" 1247 "{line.start-addr = '${line.start-addr}'\n}" 1248 "{line.end-addr = '${line.end-addr}'\n}" 1249 ; 1250 1251 SymbolContext sc (frame->GetSymbolContext(eSymbolContextEverything)); 1252 ExecutionContext exe_ctx; 1253 frame->CalculateExecutionContext(exe_ctx); 1254 if (Debugger::FormatPrompt (prompt_format, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s)) 1255 { 1256 printf("%s\n", s.GetData()); 1257 } 1258 else 1259 { 1260 printf ("what we got: %s\n", s.GetData()); 1261 } 1262 } 1263 #endif 1264 1265 bool 1266 Debugger::FormatDisassemblerAddress (const FormatEntity::Entry *format, 1267 const SymbolContext *sc, 1268 const SymbolContext *prev_sc, 1269 const ExecutionContext *exe_ctx, 1270 const Address *addr, 1271 Stream &s) 1272 { 1273 FormatEntity::Entry format_entry; 1274 1275 if (format == nullptr) 1276 { 1277 if (exe_ctx != nullptr && exe_ctx->HasTargetScope()) 1278 format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat(); 1279 if (format == nullptr) 1280 { 1281 FormatEntity::Parse("${addr}: ", format_entry); 1282 format = &format_entry; 1283 } 1284 } 1285 bool function_changed = false; 1286 bool initial_function = false; 1287 if (prev_sc && (prev_sc->function || prev_sc->symbol)) 1288 { 1289 if (sc && (sc->function || sc->symbol)) 1290 { 1291 if (prev_sc->symbol && sc->symbol) 1292 { 1293 if (!sc->symbol->Compare (prev_sc->symbol->GetName(), prev_sc->symbol->GetType())) 1294 { 1295 function_changed = true; 1296 } 1297 } 1298 else if (prev_sc->function && sc->function) 1299 { 1300 if (prev_sc->function->GetMangled() != sc->function->GetMangled()) 1301 { 1302 function_changed = true; 1303 } 1304 } 1305 } 1306 } 1307 // The first context on a list of instructions will have a prev_sc that 1308 // has no Function or Symbol -- if SymbolContext had an IsValid() method, it 1309 // would return false. But we do get a prev_sc pointer. 1310 if ((sc && (sc->function || sc->symbol)) 1311 && prev_sc && (prev_sc->function == nullptr && prev_sc->symbol == nullptr)) 1312 { 1313 initial_function = true; 1314 } 1315 return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr, function_changed, initial_function); 1316 } 1317 1318 void 1319 Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1320 { 1321 // For simplicity's sake, I am not going to deal with how to close down any 1322 // open logging streams, I just redirect everything from here on out to the 1323 // callback. 1324 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton)); 1325 } 1326 1327 bool 1328 Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream) 1329 { 1330 StreamSP log_stream_sp; 1331 if (m_log_callback_stream_sp) 1332 { 1333 log_stream_sp = m_log_callback_stream_sp; 1334 // For now when using the callback mode you always get thread & timestamp. 1335 log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1336 } 1337 else if (log_file == nullptr || *log_file == '\0') 1338 { 1339 log_stream_sp = GetOutputFile(); 1340 } 1341 else 1342 { 1343 LogStreamMap::iterator pos = m_log_streams.find(log_file); 1344 if (pos != m_log_streams.end()) 1345 log_stream_sp = pos->second.lock(); 1346 if (!log_stream_sp) 1347 { 1348 uint32_t options = File::eOpenOptionWrite | File::eOpenOptionCanCreate 1349 | File::eOpenOptionCloseOnExec | File::eOpenOptionAppend; 1350 if (! (log_options & LLDB_LOG_OPTION_APPEND)) 1351 options |= File::eOpenOptionTruncate; 1352 1353 log_stream_sp.reset (new StreamFile (log_file, options)); 1354 m_log_streams[log_file] = log_stream_sp; 1355 } 1356 } 1357 assert(log_stream_sp); 1358 1359 if (log_options == 0) 1360 log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE; 1361 1362 return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories, error_stream); 1363 } 1364 1365 SourceManager & 1366 Debugger::GetSourceManager () 1367 { 1368 if (!m_source_manager_ap) 1369 m_source_manager_ap.reset (new SourceManager (shared_from_this())); 1370 return *m_source_manager_ap; 1371 } 1372 1373 // This function handles events that were broadcast by the process. 1374 void 1375 Debugger::HandleBreakpointEvent (const EventSP &event_sp) 1376 { 1377 using namespace lldb; 1378 const uint32_t event_type = Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (event_sp); 1379 1380 // if (event_type & eBreakpointEventTypeAdded 1381 // || event_type & eBreakpointEventTypeRemoved 1382 // || event_type & eBreakpointEventTypeEnabled 1383 // || event_type & eBreakpointEventTypeDisabled 1384 // || event_type & eBreakpointEventTypeCommandChanged 1385 // || event_type & eBreakpointEventTypeConditionChanged 1386 // || event_type & eBreakpointEventTypeIgnoreChanged 1387 // || event_type & eBreakpointEventTypeLocationsResolved) 1388 // { 1389 // // Don't do anything about these events, since the breakpoint commands already echo these actions. 1390 // } 1391 // 1392 if (event_type & eBreakpointEventTypeLocationsAdded) 1393 { 1394 uint32_t num_new_locations = Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(event_sp); 1395 if (num_new_locations > 0) 1396 { 1397 BreakpointSP breakpoint = Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp); 1398 StreamSP output_sp (GetAsyncOutputStream()); 1399 if (output_sp) 1400 { 1401 output_sp->Printf("%d location%s added to breakpoint %d\n", 1402 num_new_locations, 1403 num_new_locations == 1 ? "" : "s", 1404 breakpoint->GetID()); 1405 output_sp->Flush(); 1406 } 1407 } 1408 } 1409 // else if (event_type & eBreakpointEventTypeLocationsRemoved) 1410 // { 1411 // // These locations just get disabled, not sure it is worth spamming folks about this on the command line. 1412 // } 1413 // else if (event_type & eBreakpointEventTypeLocationsResolved) 1414 // { 1415 // // This might be an interesting thing to note, but I'm going to leave it quiet for now, it just looked noisy. 1416 // } 1417 } 1418 1419 size_t 1420 Debugger::GetProcessSTDOUT (Process *process, Stream *stream) 1421 { 1422 size_t total_bytes = 0; 1423 if (stream == nullptr) 1424 stream = GetOutputFile().get(); 1425 1426 if (stream) 1427 { 1428 // The process has stuff waiting for stdout; get it and write it out to the appropriate place. 1429 if (process == nullptr) 1430 { 1431 TargetSP target_sp = GetTargetList().GetSelectedTarget(); 1432 if (target_sp) 1433 process = target_sp->GetProcessSP().get(); 1434 } 1435 if (process) 1436 { 1437 Error error; 1438 size_t len; 1439 char stdio_buffer[1024]; 1440 while ((len = process->GetSTDOUT (stdio_buffer, sizeof (stdio_buffer), error)) > 0) 1441 { 1442 stream->Write(stdio_buffer, len); 1443 total_bytes += len; 1444 } 1445 } 1446 stream->Flush(); 1447 } 1448 return total_bytes; 1449 } 1450 1451 size_t 1452 Debugger::GetProcessSTDERR (Process *process, Stream *stream) 1453 { 1454 size_t total_bytes = 0; 1455 if (stream == nullptr) 1456 stream = GetOutputFile().get(); 1457 1458 if (stream) 1459 { 1460 // The process has stuff waiting for stderr; get it and write it out to the appropriate place. 1461 if (process == nullptr) 1462 { 1463 TargetSP target_sp = GetTargetList().GetSelectedTarget(); 1464 if (target_sp) 1465 process = target_sp->GetProcessSP().get(); 1466 } 1467 if (process) 1468 { 1469 Error error; 1470 size_t len; 1471 char stdio_buffer[1024]; 1472 while ((len = process->GetSTDERR (stdio_buffer, sizeof (stdio_buffer), error)) > 0) 1473 { 1474 stream->Write(stdio_buffer, len); 1475 total_bytes += len; 1476 } 1477 } 1478 stream->Flush(); 1479 } 1480 return total_bytes; 1481 } 1482 1483 1484 // This function handles events that were broadcast by the process. 1485 void 1486 Debugger::HandleProcessEvent (const EventSP &event_sp) 1487 { 1488 using namespace lldb; 1489 const uint32_t event_type = event_sp->GetType(); 1490 ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get()); 1491 1492 StreamSP output_stream_sp = GetAsyncOutputStream(); 1493 StreamSP error_stream_sp = GetAsyncErrorStream(); 1494 const bool gui_enabled = IsForwardingEvents(); 1495 1496 if (!gui_enabled) 1497 { 1498 bool pop_process_io_handler = false; 1499 assert (process_sp); 1500 1501 bool state_is_stopped = false; 1502 const bool got_state_changed = (event_type & Process::eBroadcastBitStateChanged) != 0; 1503 const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0; 1504 const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0; 1505 if (got_state_changed) 1506 { 1507 StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get()); 1508 state_is_stopped = StateIsStoppedState(event_state, false); 1509 } 1510 1511 // Display running state changes first before any STDIO 1512 if (got_state_changed && !state_is_stopped) 1513 { 1514 Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler); 1515 } 1516 1517 // Now display and STDOUT 1518 if (got_stdout || got_state_changed) 1519 { 1520 GetProcessSTDOUT (process_sp.get(), output_stream_sp.get()); 1521 } 1522 1523 // Now display and STDERR 1524 if (got_stderr || got_state_changed) 1525 { 1526 GetProcessSTDERR (process_sp.get(), error_stream_sp.get()); 1527 } 1528 1529 // Now display any stopped state changes after any STDIO 1530 if (got_state_changed && state_is_stopped) 1531 { 1532 Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler); 1533 } 1534 1535 output_stream_sp->Flush(); 1536 error_stream_sp->Flush(); 1537 1538 if (pop_process_io_handler) 1539 process_sp->PopProcessIOHandler(); 1540 } 1541 } 1542 1543 void 1544 Debugger::HandleThreadEvent (const EventSP &event_sp) 1545 { 1546 // At present the only thread event we handle is the Frame Changed event, 1547 // and all we do for that is just reprint the thread status for that thread. 1548 using namespace lldb; 1549 const uint32_t event_type = event_sp->GetType(); 1550 if (event_type == Thread::eBroadcastBitStackChanged || 1551 event_type == Thread::eBroadcastBitThreadSelected ) 1552 { 1553 ThreadSP thread_sp (Thread::ThreadEventData::GetThreadFromEvent (event_sp.get())); 1554 if (thread_sp) 1555 { 1556 thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1); 1557 } 1558 } 1559 } 1560 1561 bool 1562 Debugger::IsForwardingEvents () 1563 { 1564 return (bool)m_forward_listener_sp; 1565 } 1566 1567 void 1568 Debugger::EnableForwardEvents (const ListenerSP &listener_sp) 1569 { 1570 m_forward_listener_sp = listener_sp; 1571 } 1572 1573 void 1574 Debugger::CancelForwardEvents (const ListenerSP &listener_sp) 1575 { 1576 m_forward_listener_sp.reset(); 1577 } 1578 1579 1580 void 1581 Debugger::DefaultEventHandler() 1582 { 1583 Listener& listener(GetListener()); 1584 ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass()); 1585 ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass()); 1586 ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass()); 1587 BroadcastEventSpec target_event_spec (broadcaster_class_target, 1588 Target::eBroadcastBitBreakpointChanged); 1589 1590 BroadcastEventSpec process_event_spec (broadcaster_class_process, 1591 Process::eBroadcastBitStateChanged | 1592 Process::eBroadcastBitSTDOUT | 1593 Process::eBroadcastBitSTDERR); 1594 1595 BroadcastEventSpec thread_event_spec (broadcaster_class_thread, 1596 Thread::eBroadcastBitStackChanged | 1597 Thread::eBroadcastBitThreadSelected ); 1598 1599 listener.StartListeningForEventSpec (*this, target_event_spec); 1600 listener.StartListeningForEventSpec (*this, process_event_spec); 1601 listener.StartListeningForEventSpec (*this, thread_event_spec); 1602 listener.StartListeningForEvents (m_command_interpreter_ap.get(), 1603 CommandInterpreter::eBroadcastBitQuitCommandReceived | 1604 CommandInterpreter::eBroadcastBitAsynchronousOutputData | 1605 CommandInterpreter::eBroadcastBitAsynchronousErrorData ); 1606 1607 // Let the thread that spawned us know that we have started up and 1608 // that we are now listening to all required events so no events get missed 1609 m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening); 1610 1611 bool done = false; 1612 while (!done) 1613 { 1614 EventSP event_sp; 1615 if (listener.WaitForEvent(nullptr, event_sp)) 1616 { 1617 if (event_sp) 1618 { 1619 Broadcaster *broadcaster = event_sp->GetBroadcaster(); 1620 if (broadcaster) 1621 { 1622 uint32_t event_type = event_sp->GetType(); 1623 ConstString broadcaster_class (broadcaster->GetBroadcasterClass()); 1624 if (broadcaster_class == broadcaster_class_process) 1625 { 1626 HandleProcessEvent (event_sp); 1627 } 1628 else if (broadcaster_class == broadcaster_class_target) 1629 { 1630 if (Breakpoint::BreakpointEventData::GetEventDataFromEvent(event_sp.get())) 1631 { 1632 HandleBreakpointEvent (event_sp); 1633 } 1634 } 1635 else if (broadcaster_class == broadcaster_class_thread) 1636 { 1637 HandleThreadEvent (event_sp); 1638 } 1639 else if (broadcaster == m_command_interpreter_ap.get()) 1640 { 1641 if (event_type & CommandInterpreter::eBroadcastBitQuitCommandReceived) 1642 { 1643 done = true; 1644 } 1645 else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousErrorData) 1646 { 1647 const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get())); 1648 if (data && data[0]) 1649 { 1650 StreamSP error_sp (GetAsyncErrorStream()); 1651 if (error_sp) 1652 { 1653 error_sp->PutCString(data); 1654 error_sp->Flush(); 1655 } 1656 } 1657 } 1658 else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousOutputData) 1659 { 1660 const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get())); 1661 if (data && data[0]) 1662 { 1663 StreamSP output_sp (GetAsyncOutputStream()); 1664 if (output_sp) 1665 { 1666 output_sp->PutCString(data); 1667 output_sp->Flush(); 1668 } 1669 } 1670 } 1671 } 1672 } 1673 1674 if (m_forward_listener_sp) 1675 m_forward_listener_sp->AddEvent(event_sp); 1676 } 1677 } 1678 } 1679 } 1680 1681 lldb::thread_result_t 1682 Debugger::EventHandlerThread (lldb::thread_arg_t arg) 1683 { 1684 ((Debugger *)arg)->DefaultEventHandler(); 1685 return NULL; 1686 } 1687 1688 bool 1689 Debugger::StartEventHandlerThread() 1690 { 1691 if (!m_event_handler_thread.IsJoinable()) 1692 { 1693 // We must synchronize with the DefaultEventHandler() thread to ensure 1694 // it is up and running and listening to events before we return from 1695 // this function. We do this by listening to events for the 1696 // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster 1697 Listener listener("lldb.debugger.event-handler"); 1698 listener.StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening); 1699 1700 // Use larger 8MB stack for this thread 1701 m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler", 1702 EventHandlerThread, 1703 this, 1704 nullptr, 1705 g_debugger_event_thread_stack_bytes); 1706 1707 // Make sure DefaultEventHandler() is running and listening to events before we return 1708 // from this function. We are only listening for events of type 1709 // eBroadcastBitEventThreadIsListening so we don't need to check the event, we just need 1710 // to wait an infinite amount of time for it (nullptr timeout as the first parameter) 1711 lldb::EventSP event_sp; 1712 listener.WaitForEvent(nullptr, event_sp); 1713 } 1714 return m_event_handler_thread.IsJoinable(); 1715 } 1716 1717 void 1718 Debugger::StopEventHandlerThread() 1719 { 1720 if (m_event_handler_thread.IsJoinable()) 1721 { 1722 GetCommandInterpreter().BroadcastEvent(CommandInterpreter::eBroadcastBitQuitCommandReceived); 1723 m_event_handler_thread.Join(nullptr); 1724 } 1725 } 1726 1727 lldb::thread_result_t 1728 Debugger::IOHandlerThread (lldb::thread_arg_t arg) 1729 { 1730 Debugger *debugger = (Debugger *)arg; 1731 debugger->ExecuteIOHandlers(); 1732 debugger->StopEventHandlerThread(); 1733 return NULL; 1734 } 1735 1736 bool 1737 Debugger::HasIOHandlerThread() 1738 { 1739 return m_io_handler_thread.IsJoinable(); 1740 } 1741 1742 bool 1743 Debugger::StartIOHandlerThread() 1744 { 1745 if (!m_io_handler_thread.IsJoinable()) 1746 m_io_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.io-handler", 1747 IOHandlerThread, 1748 this, 1749 nullptr, 1750 8*1024*1024); // Use larger 8MB stack for this thread 1751 return m_io_handler_thread.IsJoinable(); 1752 } 1753 1754 void 1755 Debugger::StopIOHandlerThread() 1756 { 1757 if (m_io_handler_thread.IsJoinable()) 1758 { 1759 if (m_input_file_sp) 1760 m_input_file_sp->GetFile().Close(); 1761 m_io_handler_thread.Join(nullptr); 1762 } 1763 } 1764 1765 void 1766 Debugger::JoinIOHandlerThread() 1767 { 1768 if (HasIOHandlerThread()) 1769 { 1770 thread_result_t result; 1771 m_io_handler_thread.Join(&result); 1772 m_io_handler_thread = LLDB_INVALID_HOST_THREAD; 1773 } 1774 } 1775 1776 Target * 1777 Debugger::GetDummyTarget() 1778 { 1779 return m_target_list.GetDummyTarget (*this).get(); 1780 } 1781 1782 Target * 1783 Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) 1784 { 1785 Target *target = nullptr; 1786 if (!prefer_dummy) 1787 { 1788 target = m_target_list.GetSelectedTarget().get(); 1789 if (target) 1790 return target; 1791 } 1792 1793 return GetDummyTarget(); 1794 } 1795 1796 Error 1797 Debugger::RunREPL (LanguageType language, const char *repl_options) 1798 { 1799 Error err; 1800 FileSpec repl_executable; 1801 1802 if (language == eLanguageTypeUnknown) 1803 { 1804 std::set<LanguageType> repl_languages; 1805 1806 Language::GetLanguagesSupportingREPLs(repl_languages); 1807 1808 if (repl_languages.size() == 1) 1809 { 1810 language = *repl_languages.begin(); 1811 } 1812 else if (repl_languages.empty()) 1813 { 1814 err.SetErrorStringWithFormat("LLDB isn't configured with support support for any REPLs."); 1815 return err; 1816 } 1817 else 1818 { 1819 err.SetErrorStringWithFormat("Multiple possible REPL languages. Please specify a language."); 1820 return err; 1821 } 1822 } 1823 1824 Target *const target = nullptr; // passing in an empty target means the REPL must create one 1825 1826 REPLSP repl_sp(REPL::Create(err, language, this, target, repl_options)); 1827 1828 if (!err.Success()) 1829 { 1830 return err; 1831 } 1832 1833 if (!repl_sp) 1834 { 1835 err.SetErrorStringWithFormat("couldn't find a REPL for %s", Language::GetNameForLanguageType(language)); 1836 return err; 1837 } 1838 1839 repl_sp->SetCompilerOptions(repl_options); 1840 repl_sp->RunLoop(); 1841 1842 return err; 1843 } 1844