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/lldb-python.h" 11 12 #include "lldb/API/SBDebugger.h" 13 14 #include "lldb/Core/Debugger.h" 15 16 #include <map> 17 18 #include "clang/AST/DeclCXX.h" 19 #include "clang/AST/Type.h" 20 21 #include "lldb/lldb-private.h" 22 #include "lldb/Core/ConnectionFileDescriptor.h" 23 #include "lldb/Core/InputReader.h" 24 #include "lldb/Core/Module.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/StreamString.h" 31 #include "lldb/Core/Timer.h" 32 #include "lldb/Core/ValueObject.h" 33 #include "lldb/Core/ValueObjectVariable.h" 34 #include "lldb/DataFormatters/DataVisualization.h" 35 #include "lldb/DataFormatters/FormatManager.h" 36 #include "lldb/Host/DynamicLibrary.h" 37 #include "lldb/Host/Terminal.h" 38 #include "lldb/Interpreter/CommandInterpreter.h" 39 #include "lldb/Interpreter/OptionValueSInt64.h" 40 #include "lldb/Interpreter/OptionValueString.h" 41 #include "lldb/Symbol/ClangASTContext.h" 42 #include "lldb/Symbol/CompileUnit.h" 43 #include "lldb/Symbol/Function.h" 44 #include "lldb/Symbol/Symbol.h" 45 #include "lldb/Symbol/VariableList.h" 46 #include "lldb/Target/TargetList.h" 47 #include "lldb/Target/Process.h" 48 #include "lldb/Target/RegisterContext.h" 49 #include "lldb/Target/StopInfo.h" 50 #include "lldb/Target/Target.h" 51 #include "lldb/Target/Thread.h" 52 #include "lldb/Utility/AnsiTerminal.h" 53 54 using namespace lldb; 55 using namespace lldb_private; 56 57 58 static uint32_t g_shared_debugger_refcount = 0; 59 static lldb::user_id_t g_unique_id = 1; 60 61 #pragma mark Static Functions 62 63 static Mutex & 64 GetDebuggerListMutex () 65 { 66 static Mutex g_mutex(Mutex::eMutexTypeRecursive); 67 return g_mutex; 68 } 69 70 typedef std::vector<DebuggerSP> DebuggerList; 71 72 static DebuggerList & 73 GetDebuggerList() 74 { 75 // hide the static debugger list inside a singleton accessor to avoid 76 // global init contructors 77 static DebuggerList g_list; 78 return g_list; 79 } 80 81 OptionEnumValueElement 82 g_show_disassembly_enum_values[] = 83 { 84 { Debugger::eStopDisassemblyTypeNever, "never", "Never show disassembly when displaying a stop context."}, 85 { Debugger::eStopDisassemblyTypeNoSource, "no-source", "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."}, 86 { Debugger::eStopDisassemblyTypeAlways, "always", "Always show disassembly when displaying a stop context."}, 87 { 0, NULL, NULL } 88 }; 89 90 OptionEnumValueElement 91 g_language_enumerators[] = 92 { 93 { eScriptLanguageNone, "none", "Disable scripting languages."}, 94 { eScriptLanguagePython, "python", "Select python as the default scripting language."}, 95 { eScriptLanguageDefault, "default", "Select the lldb default as the default scripting language."}, 96 { 0, NULL, NULL } 97 }; 98 99 #define MODULE_WITH_FUNC "{ ${module.file.basename}{`${function.name-with-args}${function.pc-offset}}}" 100 #define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}" 101 102 #define DEFAULT_THREAD_FORMAT "thread #${thread.index}: tid = ${thread.id}"\ 103 "{, ${frame.pc}}"\ 104 MODULE_WITH_FUNC\ 105 FILE_AND_LINE\ 106 "{, name = '${thread.name}}"\ 107 "{, queue = '${thread.queue}}"\ 108 "{, stop reason = ${thread.stop-reason}}"\ 109 "{\\nReturn value: ${thread.return-value}}"\ 110 "\\n" 111 112 #define DEFAULT_FRAME_FORMAT "frame #${frame.index}: ${frame.pc}"\ 113 MODULE_WITH_FUNC\ 114 FILE_AND_LINE\ 115 "\\n" 116 117 118 119 static PropertyDefinition 120 g_properties[] = 121 { 122 { "auto-confirm", OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true all confirmation prompts will receive their default reply." }, 123 { "frame-format", OptionValue::eTypeString , true, 0 , DEFAULT_FRAME_FORMAT, NULL, "The default frame format string to use when displaying stack frame information for threads." }, 124 { "notify-void", OptionValue::eTypeBoolean, true, false, NULL, NULL, "Notify the user explicitly if an expression returns void (default: false)." }, 125 { "prompt", OptionValue::eTypeString , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", NULL, "The debugger command line prompt displayed for the user." }, 126 { "script-lang", OptionValue::eTypeEnum , true, eScriptLanguagePython, NULL, g_language_enumerators, "The script language to be used for evaluating user-written scripts." }, 127 { "stop-disassembly-count", OptionValue::eTypeSInt64 , true, 4 , NULL, NULL, "The number of disassembly lines to show when displaying a stopped context." }, 128 { "stop-disassembly-display", OptionValue::eTypeEnum , true, Debugger::eStopDisassemblyTypeNoSource, NULL, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." }, 129 { "stop-line-count-after", OptionValue::eTypeSInt64 , true, 3 , NULL, NULL, "The number of sources lines to display that come after the current source line when displaying a stopped context." }, 130 { "stop-line-count-before", OptionValue::eTypeSInt64 , true, 3 , NULL, NULL, "The number of sources lines to display that come before the current source line when displaying a stopped context." }, 131 { "term-width", OptionValue::eTypeSInt64 , true, 80 , NULL, NULL, "The maximum number of columns to use for displaying text." }, 132 { "thread-format", OptionValue::eTypeString , true, 0 , DEFAULT_THREAD_FORMAT, NULL, "The default thread format string to use when displaying thread information." }, 133 { "use-external-editor", OptionValue::eTypeBoolean, true, false, NULL, NULL, "Whether to use an external editor or not." }, 134 { "use-color", OptionValue::eTypeBoolean, true, true , NULL, NULL, "Whether to use Ansi color codes or not." }, 135 136 { NULL, OptionValue::eTypeInvalid, true, 0 , NULL, NULL, NULL } 137 }; 138 139 enum 140 { 141 ePropertyAutoConfirm = 0, 142 ePropertyFrameFormat, 143 ePropertyNotiftVoid, 144 ePropertyPrompt, 145 ePropertyScriptLanguage, 146 ePropertyStopDisassemblyCount, 147 ePropertyStopDisassemblyDisplay, 148 ePropertyStopLineCountAfter, 149 ePropertyStopLineCountBefore, 150 ePropertyTerminalWidth, 151 ePropertyThreadFormat, 152 ePropertyUseExternalEditor, 153 ePropertyUseColor, 154 }; 155 156 // 157 //const char * 158 //Debugger::GetFrameFormat() const 159 //{ 160 // return m_properties_sp->GetFrameFormat(); 161 //} 162 //const char * 163 //Debugger::GetThreadFormat() const 164 //{ 165 // return m_properties_sp->GetThreadFormat(); 166 //} 167 // 168 169 170 Error 171 Debugger::SetPropertyValue (const ExecutionContext *exe_ctx, 172 VarSetOperationType op, 173 const char *property_path, 174 const char *value) 175 { 176 bool is_load_script = strcmp(property_path,"target.load-script-from-symbol-file") == 0; 177 TargetSP target_sp; 178 LoadScriptFromSymFile load_script_old_value; 179 if (is_load_script && exe_ctx->GetTargetSP()) 180 { 181 target_sp = exe_ctx->GetTargetSP(); 182 load_script_old_value = target_sp->TargetProperties::GetLoadScriptFromSymbolFile(); 183 } 184 Error error (Properties::SetPropertyValue (exe_ctx, op, property_path, value)); 185 if (error.Success()) 186 { 187 // FIXME it would be nice to have "on-change" callbacks for properties 188 if (strcmp(property_path, g_properties[ePropertyPrompt].name) == 0) 189 { 190 const char *new_prompt = GetPrompt(); 191 std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor()); 192 if (str.length()) 193 new_prompt = str.c_str(); 194 EventSP prompt_change_event_sp (new Event(CommandInterpreter::eBroadcastBitResetPrompt, new EventDataBytes (new_prompt))); 195 GetCommandInterpreter().BroadcastEvent (prompt_change_event_sp); 196 } 197 else if (strcmp(property_path, g_properties[ePropertyUseColor].name) == 0) 198 { 199 // use-color changed. Ping the prompt so it can reset the ansi terminal codes. 200 SetPrompt (GetPrompt()); 201 } 202 else if (is_load_script && target_sp && load_script_old_value == eLoadScriptFromSymFileWarn) 203 { 204 if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() == eLoadScriptFromSymFileTrue) 205 { 206 std::list<Error> errors; 207 StreamString feedback_stream; 208 if (!target_sp->LoadScriptingResources(errors,&feedback_stream)) 209 { 210 for (auto error : errors) 211 { 212 GetErrorStream().Printf("%s\n",error.AsCString()); 213 } 214 if (feedback_stream.GetSize()) 215 GetErrorStream().Printf("%s",feedback_stream.GetData()); 216 } 217 } 218 } 219 } 220 return error; 221 } 222 223 bool 224 Debugger::GetAutoConfirm () const 225 { 226 const uint32_t idx = ePropertyAutoConfirm; 227 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 228 } 229 230 const char * 231 Debugger::GetFrameFormat() const 232 { 233 const uint32_t idx = ePropertyFrameFormat; 234 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value); 235 } 236 237 bool 238 Debugger::GetNotifyVoid () const 239 { 240 const uint32_t idx = ePropertyNotiftVoid; 241 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 242 } 243 244 const char * 245 Debugger::GetPrompt() const 246 { 247 const uint32_t idx = ePropertyPrompt; 248 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value); 249 } 250 251 void 252 Debugger::SetPrompt(const char *p) 253 { 254 const uint32_t idx = ePropertyPrompt; 255 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 256 const char *new_prompt = GetPrompt(); 257 std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor()); 258 if (str.length()) 259 new_prompt = str.c_str(); 260 EventSP prompt_change_event_sp (new Event(CommandInterpreter::eBroadcastBitResetPrompt, new EventDataBytes (new_prompt)));; 261 GetCommandInterpreter().BroadcastEvent (prompt_change_event_sp); 262 } 263 264 const char * 265 Debugger::GetThreadFormat() const 266 { 267 const uint32_t idx = ePropertyThreadFormat; 268 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value); 269 } 270 271 lldb::ScriptLanguage 272 Debugger::GetScriptLanguage() const 273 { 274 const uint32_t idx = ePropertyScriptLanguage; 275 return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 276 } 277 278 bool 279 Debugger::SetScriptLanguage (lldb::ScriptLanguage script_lang) 280 { 281 const uint32_t idx = ePropertyScriptLanguage; 282 return m_collection_sp->SetPropertyAtIndexAsEnumeration (NULL, idx, script_lang); 283 } 284 285 uint32_t 286 Debugger::GetTerminalWidth () const 287 { 288 const uint32_t idx = ePropertyTerminalWidth; 289 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 290 } 291 292 bool 293 Debugger::SetTerminalWidth (uint32_t term_width) 294 { 295 const uint32_t idx = ePropertyTerminalWidth; 296 return m_collection_sp->SetPropertyAtIndexAsSInt64 (NULL, idx, term_width); 297 } 298 299 bool 300 Debugger::GetUseExternalEditor () const 301 { 302 const uint32_t idx = ePropertyUseExternalEditor; 303 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 304 } 305 306 bool 307 Debugger::SetUseExternalEditor (bool b) 308 { 309 const uint32_t idx = ePropertyUseExternalEditor; 310 return m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 311 } 312 313 bool 314 Debugger::GetUseColor () const 315 { 316 const uint32_t idx = ePropertyUseColor; 317 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 318 } 319 320 bool 321 Debugger::SetUseColor (bool b) 322 { 323 const uint32_t idx = ePropertyUseColor; 324 bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 325 SetPrompt (GetPrompt()); 326 return ret; 327 } 328 329 uint32_t 330 Debugger::GetStopSourceLineCount (bool before) const 331 { 332 const uint32_t idx = before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter; 333 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 334 } 335 336 Debugger::StopDisassemblyType 337 Debugger::GetStopDisassemblyDisplay () const 338 { 339 const uint32_t idx = ePropertyStopDisassemblyDisplay; 340 return (Debugger::StopDisassemblyType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 341 } 342 343 uint32_t 344 Debugger::GetDisassemblyLineCount () const 345 { 346 const uint32_t idx = ePropertyStopDisassemblyCount; 347 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 348 } 349 350 #pragma mark Debugger 351 352 //const DebuggerPropertiesSP & 353 //Debugger::GetSettings() const 354 //{ 355 // return m_properties_sp; 356 //} 357 // 358 359 int 360 Debugger::TestDebuggerRefCount () 361 { 362 return g_shared_debugger_refcount; 363 } 364 365 void 366 Debugger::Initialize () 367 { 368 if (g_shared_debugger_refcount++ == 0) 369 lldb_private::Initialize(); 370 } 371 372 void 373 Debugger::Terminate () 374 { 375 if (g_shared_debugger_refcount > 0) 376 { 377 g_shared_debugger_refcount--; 378 if (g_shared_debugger_refcount == 0) 379 { 380 lldb_private::WillTerminate(); 381 lldb_private::Terminate(); 382 383 // Clear our master list of debugger objects 384 Mutex::Locker locker (GetDebuggerListMutex ()); 385 GetDebuggerList().clear(); 386 } 387 } 388 } 389 390 void 391 Debugger::SettingsInitialize () 392 { 393 Target::SettingsInitialize (); 394 } 395 396 void 397 Debugger::SettingsTerminate () 398 { 399 Target::SettingsTerminate (); 400 } 401 402 bool 403 Debugger::LoadPlugin (const FileSpec& spec, Error& error) 404 { 405 lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec)); 406 if (!dynlib_sp || dynlib_sp->IsValid() == false) 407 { 408 if (spec.Exists()) 409 error.SetErrorString("this file does not represent a loadable dylib"); 410 else 411 error.SetErrorString("no such file"); 412 return false; 413 } 414 lldb::DebuggerSP debugger_sp(shared_from_this()); 415 lldb::SBDebugger debugger_sb(debugger_sp); 416 // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays 417 LLDBCommandPluginInit init_func = dynlib_sp->GetSymbol<LLDBCommandPluginInit>("_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 418 if (!init_func) 419 { 420 error.SetErrorString("cannot find the initialization function lldb::PluginInitialize(lldb::SBDebugger)"); 421 return false; 422 } 423 if (init_func(debugger_sb)) 424 { 425 m_loaded_plugins.push_back(dynlib_sp); 426 return true; 427 } 428 error.SetErrorString("dylib refused to be loaded"); 429 return false; 430 } 431 432 static FileSpec::EnumerateDirectoryResult 433 LoadPluginCallback 434 ( 435 void *baton, 436 FileSpec::FileType file_type, 437 const FileSpec &file_spec 438 ) 439 { 440 Error error; 441 442 static ConstString g_dylibext("dylib"); 443 444 if (!baton) 445 return FileSpec::eEnumerateDirectoryResultQuit; 446 447 Debugger *debugger = (Debugger*)baton; 448 449 // If we have a regular file, a symbolic link or unknown file type, try 450 // and process the file. We must handle unknown as sometimes the directory 451 // enumeration might be enumerating a file system that doesn't have correct 452 // file type information. 453 if (file_type == FileSpec::eFileTypeRegular || 454 file_type == FileSpec::eFileTypeSymbolicLink || 455 file_type == FileSpec::eFileTypeUnknown ) 456 { 457 FileSpec plugin_file_spec (file_spec); 458 plugin_file_spec.ResolvePath (); 459 460 if (plugin_file_spec.GetFileNameExtension() != g_dylibext) 461 return FileSpec::eEnumerateDirectoryResultNext; 462 463 Error plugin_load_error; 464 debugger->LoadPlugin (plugin_file_spec, plugin_load_error); 465 466 return FileSpec::eEnumerateDirectoryResultNext; 467 } 468 469 else if (file_type == FileSpec::eFileTypeUnknown || 470 file_type == FileSpec::eFileTypeDirectory || 471 file_type == FileSpec::eFileTypeSymbolicLink ) 472 { 473 // Try and recurse into anything that a directory or symbolic link. 474 // We must also do this for unknown as sometimes the directory enumeration 475 // might be enurating a file system that doesn't have correct file type 476 // information. 477 return FileSpec::eEnumerateDirectoryResultEnter; 478 } 479 480 return FileSpec::eEnumerateDirectoryResultNext; 481 } 482 483 void 484 Debugger::InstanceInitialize () 485 { 486 FileSpec dir_spec; 487 const bool find_directories = true; 488 const bool find_files = true; 489 const bool find_other = true; 490 char dir_path[PATH_MAX]; 491 if (Host::GetLLDBPath (ePathTypeLLDBSystemPlugins, dir_spec)) 492 { 493 if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) 494 { 495 FileSpec::EnumerateDirectory (dir_path, 496 find_directories, 497 find_files, 498 find_other, 499 LoadPluginCallback, 500 this); 501 } 502 } 503 504 if (Host::GetLLDBPath (ePathTypeLLDBUserPlugins, dir_spec)) 505 { 506 if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) 507 { 508 FileSpec::EnumerateDirectory (dir_path, 509 find_directories, 510 find_files, 511 find_other, 512 LoadPluginCallback, 513 this); 514 } 515 } 516 517 PluginManager::DebuggerInitialize (*this); 518 } 519 520 DebuggerSP 521 Debugger::CreateInstance (lldb::LogOutputCallback log_callback, void *baton) 522 { 523 DebuggerSP debugger_sp (new Debugger(log_callback, baton)); 524 if (g_shared_debugger_refcount > 0) 525 { 526 Mutex::Locker locker (GetDebuggerListMutex ()); 527 GetDebuggerList().push_back(debugger_sp); 528 } 529 debugger_sp->InstanceInitialize (); 530 return debugger_sp; 531 } 532 533 void 534 Debugger::Destroy (DebuggerSP &debugger_sp) 535 { 536 if (debugger_sp.get() == NULL) 537 return; 538 539 debugger_sp->Clear(); 540 541 if (g_shared_debugger_refcount > 0) 542 { 543 Mutex::Locker locker (GetDebuggerListMutex ()); 544 DebuggerList &debugger_list = GetDebuggerList (); 545 DebuggerList::iterator pos, end = debugger_list.end(); 546 for (pos = debugger_list.begin (); pos != end; ++pos) 547 { 548 if ((*pos).get() == debugger_sp.get()) 549 { 550 debugger_list.erase (pos); 551 return; 552 } 553 } 554 } 555 } 556 557 DebuggerSP 558 Debugger::FindDebuggerWithInstanceName (const ConstString &instance_name) 559 { 560 DebuggerSP debugger_sp; 561 if (g_shared_debugger_refcount > 0) 562 { 563 Mutex::Locker locker (GetDebuggerListMutex ()); 564 DebuggerList &debugger_list = GetDebuggerList(); 565 DebuggerList::iterator pos, end = debugger_list.end(); 566 567 for (pos = debugger_list.begin(); pos != end; ++pos) 568 { 569 if ((*pos).get()->m_instance_name == instance_name) 570 { 571 debugger_sp = *pos; 572 break; 573 } 574 } 575 } 576 return debugger_sp; 577 } 578 579 TargetSP 580 Debugger::FindTargetWithProcessID (lldb::pid_t pid) 581 { 582 TargetSP target_sp; 583 if (g_shared_debugger_refcount > 0) 584 { 585 Mutex::Locker locker (GetDebuggerListMutex ()); 586 DebuggerList &debugger_list = GetDebuggerList(); 587 DebuggerList::iterator pos, end = debugger_list.end(); 588 for (pos = debugger_list.begin(); pos != end; ++pos) 589 { 590 target_sp = (*pos)->GetTargetList().FindTargetWithProcessID (pid); 591 if (target_sp) 592 break; 593 } 594 } 595 return target_sp; 596 } 597 598 TargetSP 599 Debugger::FindTargetWithProcess (Process *process) 600 { 601 TargetSP target_sp; 602 if (g_shared_debugger_refcount > 0) 603 { 604 Mutex::Locker locker (GetDebuggerListMutex ()); 605 DebuggerList &debugger_list = GetDebuggerList(); 606 DebuggerList::iterator pos, end = debugger_list.end(); 607 for (pos = debugger_list.begin(); pos != end; ++pos) 608 { 609 target_sp = (*pos)->GetTargetList().FindTargetWithProcess (process); 610 if (target_sp) 611 break; 612 } 613 } 614 return target_sp; 615 } 616 617 Debugger::Debugger (lldb::LogOutputCallback log_callback, void *baton) : 618 UserID (g_unique_id++), 619 Properties(OptionValuePropertiesSP(new OptionValueProperties())), 620 m_input_comm("debugger.input"), 621 m_input_file (), 622 m_output_file (), 623 m_error_file (), 624 m_terminal_state (), 625 m_target_list (*this), 626 m_platform_list (), 627 m_listener ("lldb.Debugger"), 628 m_source_manager_ap(), 629 m_source_file_cache(), 630 m_command_interpreter_ap (new CommandInterpreter (*this, eScriptLanguageDefault, false)), 631 m_input_reader_stack (), 632 m_input_reader_data (), 633 m_instance_name() 634 { 635 char instance_cstr[256]; 636 snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID()); 637 m_instance_name.SetCString(instance_cstr); 638 if (log_callback) 639 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton)); 640 m_command_interpreter_ap->Initialize (); 641 // Always add our default platform to the platform list 642 PlatformSP default_platform_sp (Platform::GetDefaultPlatform()); 643 assert (default_platform_sp.get()); 644 m_platform_list.Append (default_platform_sp, true); 645 646 m_collection_sp->Initialize (g_properties); 647 m_collection_sp->AppendProperty (ConstString("target"), 648 ConstString("Settings specify to debugging targets."), 649 true, 650 Target::GetGlobalProperties()->GetValueProperties()); 651 if (m_command_interpreter_ap.get()) 652 { 653 m_collection_sp->AppendProperty (ConstString("interpreter"), 654 ConstString("Settings specify to the debugger's command interpreter."), 655 true, 656 m_command_interpreter_ap->GetValueProperties()); 657 } 658 OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64 (NULL, ePropertyTerminalWidth); 659 term_width->SetMinimumValue(10); 660 term_width->SetMaximumValue(1024); 661 662 // Turn off use-color if this is a dumb terminal. 663 const char *term = getenv ("TERM"); 664 if (term && !strcmp (term, "dumb")) 665 SetUseColor (false); 666 } 667 668 Debugger::~Debugger () 669 { 670 Clear(); 671 } 672 673 void 674 Debugger::Clear() 675 { 676 CleanUpInputReaders(); 677 m_listener.Clear(); 678 int num_targets = m_target_list.GetNumTargets(); 679 for (int i = 0; i < num_targets; i++) 680 { 681 TargetSP target_sp (m_target_list.GetTargetAtIndex (i)); 682 if (target_sp) 683 { 684 ProcessSP process_sp (target_sp->GetProcessSP()); 685 if (process_sp) 686 process_sp->Finalize(); 687 target_sp->Destroy(); 688 } 689 } 690 BroadcasterManager::Clear (); 691 692 // Close the input file _before_ we close the input read communications class 693 // as it does NOT own the input file, our m_input_file does. 694 m_terminal_state.Clear(); 695 GetInputFile().Close (); 696 // Now that we have closed m_input_file, we can now tell our input communication 697 // class to close down. Its read thread should quickly exit after we close 698 // the input file handle above. 699 m_input_comm.Clear (); 700 } 701 702 bool 703 Debugger::GetCloseInputOnEOF () const 704 { 705 return m_input_comm.GetCloseOnEOF(); 706 } 707 708 void 709 Debugger::SetCloseInputOnEOF (bool b) 710 { 711 m_input_comm.SetCloseOnEOF(b); 712 } 713 714 bool 715 Debugger::GetAsyncExecution () 716 { 717 return !m_command_interpreter_ap->GetSynchronous(); 718 } 719 720 void 721 Debugger::SetAsyncExecution (bool async_execution) 722 { 723 m_command_interpreter_ap->SetSynchronous (!async_execution); 724 } 725 726 727 void 728 Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership) 729 { 730 File &in_file = GetInputFile(); 731 in_file.SetStream (fh, tranfer_ownership); 732 if (in_file.IsValid() == false) 733 in_file.SetStream (stdin, true); 734 735 // Disconnect from any old connection if we had one 736 m_input_comm.Disconnect (); 737 // Pass false as the second argument to ConnectionFileDescriptor below because 738 // our "in_file" above will already take ownership if requested and we don't 739 // want to objects trying to own and close a file descriptor. 740 m_input_comm.SetConnection (new ConnectionFileDescriptor (in_file.GetDescriptor(), false)); 741 m_input_comm.SetReadThreadBytesReceivedCallback (Debugger::DispatchInputCallback, this); 742 743 // Save away the terminal state if that is relevant, so that we can restore it in RestoreInputState. 744 SaveInputTerminalState (); 745 746 Error error; 747 if (m_input_comm.StartReadThread (&error) == false) 748 { 749 File &err_file = GetErrorFile(); 750 751 err_file.Printf ("error: failed to main input read thread: %s", error.AsCString() ? error.AsCString() : "unkown error"); 752 exit(1); 753 } 754 } 755 756 void 757 Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership) 758 { 759 File &out_file = GetOutputFile(); 760 out_file.SetStream (fh, tranfer_ownership); 761 if (out_file.IsValid() == false) 762 out_file.SetStream (stdout, false); 763 764 // do not create the ScriptInterpreter just for setting the output file handle 765 // as the constructor will know how to do the right thing on its own 766 const bool can_create = false; 767 ScriptInterpreter* script_interpreter = GetCommandInterpreter().GetScriptInterpreter(can_create); 768 if (script_interpreter) 769 script_interpreter->ResetOutputFileHandle (fh); 770 } 771 772 void 773 Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership) 774 { 775 File &err_file = GetErrorFile(); 776 err_file.SetStream (fh, tranfer_ownership); 777 if (err_file.IsValid() == false) 778 err_file.SetStream (stderr, false); 779 } 780 781 void 782 Debugger::SaveInputTerminalState () 783 { 784 File &in_file = GetInputFile(); 785 if (in_file.GetDescriptor() != File::kInvalidDescriptor) 786 m_terminal_state.Save(in_file.GetDescriptor(), true); 787 } 788 789 void 790 Debugger::RestoreInputTerminalState () 791 { 792 m_terminal_state.Restore(); 793 } 794 795 ExecutionContext 796 Debugger::GetSelectedExecutionContext () 797 { 798 ExecutionContext exe_ctx; 799 TargetSP target_sp(GetSelectedTarget()); 800 exe_ctx.SetTargetSP (target_sp); 801 802 if (target_sp) 803 { 804 ProcessSP process_sp (target_sp->GetProcessSP()); 805 exe_ctx.SetProcessSP (process_sp); 806 if (process_sp && process_sp->IsRunning() == false) 807 { 808 ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread()); 809 if (thread_sp) 810 { 811 exe_ctx.SetThreadSP (thread_sp); 812 exe_ctx.SetFrameSP (thread_sp->GetSelectedFrame()); 813 if (exe_ctx.GetFramePtr() == NULL) 814 exe_ctx.SetFrameSP (thread_sp->GetStackFrameAtIndex (0)); 815 } 816 } 817 } 818 return exe_ctx; 819 820 } 821 822 InputReaderSP 823 Debugger::GetCurrentInputReader () 824 { 825 InputReaderSP reader_sp; 826 827 if (!m_input_reader_stack.IsEmpty()) 828 { 829 // Clear any finished readers from the stack 830 while (CheckIfTopInputReaderIsDone()) ; 831 832 if (!m_input_reader_stack.IsEmpty()) 833 reader_sp = m_input_reader_stack.Top(); 834 } 835 836 return reader_sp; 837 } 838 839 void 840 Debugger::DispatchInputCallback (void *baton, const void *bytes, size_t bytes_len) 841 { 842 if (bytes_len > 0) 843 ((Debugger *)baton)->DispatchInput ((char *)bytes, bytes_len); 844 else 845 ((Debugger *)baton)->DispatchInputEndOfFile (); 846 } 847 848 849 void 850 Debugger::DispatchInput (const char *bytes, size_t bytes_len) 851 { 852 if (bytes == NULL || bytes_len == 0) 853 return; 854 855 WriteToDefaultReader (bytes, bytes_len); 856 } 857 858 void 859 Debugger::DispatchInputInterrupt () 860 { 861 m_input_reader_data.clear(); 862 863 InputReaderSP reader_sp (GetCurrentInputReader ()); 864 if (reader_sp) 865 { 866 reader_sp->Notify (eInputReaderInterrupt); 867 868 // If notifying the reader of the interrupt finished the reader, we should pop it off the stack. 869 while (CheckIfTopInputReaderIsDone ()) ; 870 } 871 } 872 873 void 874 Debugger::DispatchInputEndOfFile () 875 { 876 m_input_reader_data.clear(); 877 878 InputReaderSP reader_sp (GetCurrentInputReader ()); 879 if (reader_sp) 880 { 881 reader_sp->Notify (eInputReaderEndOfFile); 882 883 // If notifying the reader of the end-of-file finished the reader, we should pop it off the stack. 884 while (CheckIfTopInputReaderIsDone ()) ; 885 } 886 } 887 888 void 889 Debugger::CleanUpInputReaders () 890 { 891 m_input_reader_data.clear(); 892 893 // The bottom input reader should be the main debugger input reader. We do not want to close that one here. 894 while (m_input_reader_stack.GetSize() > 1) 895 { 896 InputReaderSP reader_sp (GetCurrentInputReader ()); 897 if (reader_sp) 898 { 899 reader_sp->Notify (eInputReaderEndOfFile); 900 reader_sp->SetIsDone (true); 901 } 902 } 903 } 904 905 void 906 Debugger::NotifyTopInputReader (InputReaderAction notification) 907 { 908 InputReaderSP reader_sp (GetCurrentInputReader()); 909 if (reader_sp) 910 { 911 reader_sp->Notify (notification); 912 913 // Flush out any input readers that are done. 914 while (CheckIfTopInputReaderIsDone ()) 915 /* Do nothing. */; 916 } 917 } 918 919 bool 920 Debugger::InputReaderIsTopReader (const InputReaderSP& reader_sp) 921 { 922 InputReaderSP top_reader_sp (GetCurrentInputReader()); 923 924 return (reader_sp.get() == top_reader_sp.get()); 925 } 926 927 928 void 929 Debugger::WriteToDefaultReader (const char *bytes, size_t bytes_len) 930 { 931 if (bytes && bytes_len) 932 m_input_reader_data.append (bytes, bytes_len); 933 934 if (m_input_reader_data.empty()) 935 return; 936 937 while (!m_input_reader_stack.IsEmpty() && !m_input_reader_data.empty()) 938 { 939 // Get the input reader from the top of the stack 940 InputReaderSP reader_sp (GetCurrentInputReader ()); 941 if (!reader_sp) 942 break; 943 944 size_t bytes_handled = reader_sp->HandleRawBytes (m_input_reader_data.c_str(), 945 m_input_reader_data.size()); 946 if (bytes_handled) 947 { 948 m_input_reader_data.erase (0, bytes_handled); 949 } 950 else 951 { 952 // No bytes were handled, we might not have reached our 953 // granularity, just return and wait for more data 954 break; 955 } 956 } 957 958 // Flush out any input readers that are done. 959 while (CheckIfTopInputReaderIsDone ()) 960 /* Do nothing. */; 961 962 } 963 964 void 965 Debugger::PushInputReader (const InputReaderSP& reader_sp) 966 { 967 if (!reader_sp) 968 return; 969 970 // Deactivate the old top reader 971 InputReaderSP top_reader_sp (GetCurrentInputReader ()); 972 973 if (top_reader_sp) 974 top_reader_sp->Notify (eInputReaderDeactivate); 975 976 m_input_reader_stack.Push (reader_sp); 977 reader_sp->Notify (eInputReaderActivate); 978 ActivateInputReader (reader_sp); 979 } 980 981 bool 982 Debugger::PopInputReader (const InputReaderSP& pop_reader_sp) 983 { 984 bool result = false; 985 986 // The reader on the stop of the stack is done, so let the next 987 // read on the stack referesh its prompt and if there is one... 988 if (!m_input_reader_stack.IsEmpty()) 989 { 990 // Cannot call GetCurrentInputReader here, as that would cause an infinite loop. 991 InputReaderSP reader_sp(m_input_reader_stack.Top()); 992 993 if (!pop_reader_sp || pop_reader_sp.get() == reader_sp.get()) 994 { 995 m_input_reader_stack.Pop (); 996 reader_sp->Notify (eInputReaderDeactivate); 997 reader_sp->Notify (eInputReaderDone); 998 result = true; 999 1000 if (!m_input_reader_stack.IsEmpty()) 1001 { 1002 reader_sp = m_input_reader_stack.Top(); 1003 if (reader_sp) 1004 { 1005 ActivateInputReader (reader_sp); 1006 reader_sp->Notify (eInputReaderReactivate); 1007 } 1008 } 1009 } 1010 } 1011 return result; 1012 } 1013 1014 bool 1015 Debugger::CheckIfTopInputReaderIsDone () 1016 { 1017 bool result = false; 1018 if (!m_input_reader_stack.IsEmpty()) 1019 { 1020 // Cannot call GetCurrentInputReader here, as that would cause an infinite loop. 1021 InputReaderSP reader_sp(m_input_reader_stack.Top()); 1022 1023 if (reader_sp && reader_sp->IsDone()) 1024 { 1025 result = true; 1026 PopInputReader (reader_sp); 1027 } 1028 } 1029 return result; 1030 } 1031 1032 void 1033 Debugger::ActivateInputReader (const InputReaderSP &reader_sp) 1034 { 1035 int input_fd = m_input_file.GetFile().GetDescriptor(); 1036 1037 if (input_fd >= 0) 1038 { 1039 Terminal tty(input_fd); 1040 1041 tty.SetEcho(reader_sp->GetEcho()); 1042 1043 switch (reader_sp->GetGranularity()) 1044 { 1045 case eInputReaderGranularityByte: 1046 case eInputReaderGranularityWord: 1047 tty.SetCanonical (false); 1048 break; 1049 1050 case eInputReaderGranularityLine: 1051 case eInputReaderGranularityAll: 1052 tty.SetCanonical (true); 1053 break; 1054 1055 default: 1056 break; 1057 } 1058 } 1059 } 1060 1061 StreamSP 1062 Debugger::GetAsyncOutputStream () 1063 { 1064 return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(), 1065 CommandInterpreter::eBroadcastBitAsynchronousOutputData)); 1066 } 1067 1068 StreamSP 1069 Debugger::GetAsyncErrorStream () 1070 { 1071 return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(), 1072 CommandInterpreter::eBroadcastBitAsynchronousErrorData)); 1073 } 1074 1075 size_t 1076 Debugger::GetNumDebuggers() 1077 { 1078 if (g_shared_debugger_refcount > 0) 1079 { 1080 Mutex::Locker locker (GetDebuggerListMutex ()); 1081 return GetDebuggerList().size(); 1082 } 1083 return 0; 1084 } 1085 1086 lldb::DebuggerSP 1087 Debugger::GetDebuggerAtIndex (size_t index) 1088 { 1089 DebuggerSP debugger_sp; 1090 1091 if (g_shared_debugger_refcount > 0) 1092 { 1093 Mutex::Locker locker (GetDebuggerListMutex ()); 1094 DebuggerList &debugger_list = GetDebuggerList(); 1095 1096 if (index < debugger_list.size()) 1097 debugger_sp = debugger_list[index]; 1098 } 1099 1100 return debugger_sp; 1101 } 1102 1103 DebuggerSP 1104 Debugger::FindDebuggerWithID (lldb::user_id_t id) 1105 { 1106 DebuggerSP debugger_sp; 1107 1108 if (g_shared_debugger_refcount > 0) 1109 { 1110 Mutex::Locker locker (GetDebuggerListMutex ()); 1111 DebuggerList &debugger_list = GetDebuggerList(); 1112 DebuggerList::iterator pos, end = debugger_list.end(); 1113 for (pos = debugger_list.begin(); pos != end; ++pos) 1114 { 1115 if ((*pos).get()->GetID() == id) 1116 { 1117 debugger_sp = *pos; 1118 break; 1119 } 1120 } 1121 } 1122 return debugger_sp; 1123 } 1124 1125 static void 1126 TestPromptFormats (StackFrame *frame) 1127 { 1128 if (frame == NULL) 1129 return; 1130 1131 StreamString s; 1132 const char *prompt_format = 1133 "{addr = '${addr}'\n}" 1134 "{process.id = '${process.id}'\n}" 1135 "{process.name = '${process.name}'\n}" 1136 "{process.file.basename = '${process.file.basename}'\n}" 1137 "{process.file.fullpath = '${process.file.fullpath}'\n}" 1138 "{thread.id = '${thread.id}'\n}" 1139 "{thread.index = '${thread.index}'\n}" 1140 "{thread.name = '${thread.name}'\n}" 1141 "{thread.queue = '${thread.queue}'\n}" 1142 "{thread.stop-reason = '${thread.stop-reason}'\n}" 1143 "{target.arch = '${target.arch}'\n}" 1144 "{module.file.basename = '${module.file.basename}'\n}" 1145 "{module.file.fullpath = '${module.file.fullpath}'\n}" 1146 "{file.basename = '${file.basename}'\n}" 1147 "{file.fullpath = '${file.fullpath}'\n}" 1148 "{frame.index = '${frame.index}'\n}" 1149 "{frame.pc = '${frame.pc}'\n}" 1150 "{frame.sp = '${frame.sp}'\n}" 1151 "{frame.fp = '${frame.fp}'\n}" 1152 "{frame.flags = '${frame.flags}'\n}" 1153 "{frame.reg.rdi = '${frame.reg.rdi}'\n}" 1154 "{frame.reg.rip = '${frame.reg.rip}'\n}" 1155 "{frame.reg.rsp = '${frame.reg.rsp}'\n}" 1156 "{frame.reg.rbp = '${frame.reg.rbp}'\n}" 1157 "{frame.reg.rflags = '${frame.reg.rflags}'\n}" 1158 "{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}" 1159 "{frame.reg.carp = '${frame.reg.carp}'\n}" 1160 "{function.id = '${function.id}'\n}" 1161 "{function.name = '${function.name}'\n}" 1162 "{function.name-with-args = '${function.name-with-args}'\n}" 1163 "{function.addr-offset = '${function.addr-offset}'\n}" 1164 "{function.line-offset = '${function.line-offset}'\n}" 1165 "{function.pc-offset = '${function.pc-offset}'\n}" 1166 "{line.file.basename = '${line.file.basename}'\n}" 1167 "{line.file.fullpath = '${line.file.fullpath}'\n}" 1168 "{line.number = '${line.number}'\n}" 1169 "{line.start-addr = '${line.start-addr}'\n}" 1170 "{line.end-addr = '${line.end-addr}'\n}" 1171 ; 1172 1173 SymbolContext sc (frame->GetSymbolContext(eSymbolContextEverything)); 1174 ExecutionContext exe_ctx; 1175 frame->CalculateExecutionContext(exe_ctx); 1176 if (Debugger::FormatPrompt (prompt_format, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s)) 1177 { 1178 printf("%s\n", s.GetData()); 1179 } 1180 else 1181 { 1182 printf ("what we got: %s\n", s.GetData()); 1183 } 1184 } 1185 1186 static bool 1187 ScanFormatDescriptor (const char* var_name_begin, 1188 const char* var_name_end, 1189 const char** var_name_final, 1190 const char** percent_position, 1191 Format* custom_format, 1192 ValueObject::ValueObjectRepresentationStyle* val_obj_display) 1193 { 1194 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 1195 *percent_position = ::strchr(var_name_begin,'%'); 1196 if (!*percent_position || *percent_position > var_name_end) 1197 { 1198 if (log) 1199 log->Printf("[ScanFormatDescriptor] no format descriptor in string, skipping"); 1200 *var_name_final = var_name_end; 1201 } 1202 else 1203 { 1204 *var_name_final = *percent_position; 1205 std::string format_name(*var_name_final+1, var_name_end-*var_name_final-1); 1206 if (log) 1207 log->Printf("[ScanFormatDescriptor] parsing %s as a format descriptor", format_name.c_str()); 1208 if ( !FormatManager::GetFormatFromCString(format_name.c_str(), 1209 true, 1210 *custom_format) ) 1211 { 1212 if (log) 1213 log->Printf("[ScanFormatDescriptor] %s is an unknown format", format_name.c_str()); 1214 1215 switch (format_name.front()) 1216 { 1217 case '@': // if this is an @ sign, print ObjC description 1218 *val_obj_display = ValueObject::eValueObjectRepresentationStyleLanguageSpecific; 1219 break; 1220 case 'V': // if this is a V, print the value using the default format 1221 *val_obj_display = ValueObject::eValueObjectRepresentationStyleValue; 1222 break; 1223 case 'L': // if this is an L, print the location of the value 1224 *val_obj_display = ValueObject::eValueObjectRepresentationStyleLocation; 1225 break; 1226 case 'S': // if this is an S, print the summary after all 1227 *val_obj_display = ValueObject::eValueObjectRepresentationStyleSummary; 1228 break; 1229 case '#': // if this is a '#', print the number of children 1230 *val_obj_display = ValueObject::eValueObjectRepresentationStyleChildrenCount; 1231 break; 1232 case 'T': // if this is a 'T', print the type 1233 *val_obj_display = ValueObject::eValueObjectRepresentationStyleType; 1234 break; 1235 case 'N': // if this is a 'N', print the name 1236 *val_obj_display = ValueObject::eValueObjectRepresentationStyleName; 1237 break; 1238 case '>': // if this is a '>', print the name 1239 *val_obj_display = ValueObject::eValueObjectRepresentationStyleExpressionPath; 1240 break; 1241 default: 1242 if (log) 1243 log->Printf("ScanFormatDescriptor] %s is an error, leaving the previous value alone", format_name.c_str()); 1244 break; 1245 } 1246 } 1247 // a good custom format tells us to print the value using it 1248 else 1249 { 1250 if (log) 1251 log->Printf("[ScanFormatDescriptor] will display value for this VO"); 1252 *val_obj_display = ValueObject::eValueObjectRepresentationStyleValue; 1253 } 1254 } 1255 if (log) 1256 log->Printf("[ScanFormatDescriptor] final format description outcome: custom_format = %d, val_obj_display = %d", 1257 *custom_format, 1258 *val_obj_display); 1259 return true; 1260 } 1261 1262 static bool 1263 ScanBracketedRange (const char* var_name_begin, 1264 const char* var_name_end, 1265 const char* var_name_final, 1266 const char** open_bracket_position, 1267 const char** separator_position, 1268 const char** close_bracket_position, 1269 const char** var_name_final_if_array_range, 1270 int64_t* index_lower, 1271 int64_t* index_higher) 1272 { 1273 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 1274 *open_bracket_position = ::strchr(var_name_begin,'['); 1275 if (*open_bracket_position && *open_bracket_position < var_name_final) 1276 { 1277 *separator_position = ::strchr(*open_bracket_position,'-'); // might be NULL if this is a simple var[N] bitfield 1278 *close_bracket_position = ::strchr(*open_bracket_position,']'); 1279 // as usual, we assume that [] will come before % 1280 //printf("trying to expand a []\n"); 1281 *var_name_final_if_array_range = *open_bracket_position; 1282 if (*close_bracket_position - *open_bracket_position == 1) 1283 { 1284 if (log) 1285 log->Printf("[ScanBracketedRange] '[]' detected.. going from 0 to end of data"); 1286 *index_lower = 0; 1287 } 1288 else if (*separator_position == NULL || *separator_position > var_name_end) 1289 { 1290 char *end = NULL; 1291 *index_lower = ::strtoul (*open_bracket_position+1, &end, 0); 1292 *index_higher = *index_lower; 1293 if (log) 1294 log->Printf("[ScanBracketedRange] [%" PRId64 "] detected, high index is same", *index_lower); 1295 } 1296 else if (*close_bracket_position && *close_bracket_position < var_name_end) 1297 { 1298 char *end = NULL; 1299 *index_lower = ::strtoul (*open_bracket_position+1, &end, 0); 1300 *index_higher = ::strtoul (*separator_position+1, &end, 0); 1301 if (log) 1302 log->Printf("[ScanBracketedRange] [%" PRId64 "-%" PRId64 "] detected", *index_lower, *index_higher); 1303 } 1304 else 1305 { 1306 if (log) 1307 log->Printf("[ScanBracketedRange] expression is erroneous, cannot extract indices out of it"); 1308 return false; 1309 } 1310 if (*index_lower > *index_higher && *index_higher > 0) 1311 { 1312 if (log) 1313 log->Printf("[ScanBracketedRange] swapping indices"); 1314 int64_t temp = *index_lower; 1315 *index_lower = *index_higher; 1316 *index_higher = temp; 1317 } 1318 } 1319 else if (log) 1320 log->Printf("[ScanBracketedRange] no bracketed range, skipping entirely"); 1321 return true; 1322 } 1323 1324 static ValueObjectSP 1325 ExpandIndexedExpression (ValueObject* valobj, 1326 size_t index, 1327 StackFrame* frame, 1328 bool deref_pointer) 1329 { 1330 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 1331 const char* ptr_deref_format = "[%d]"; 1332 std::string ptr_deref_buffer(10,0); 1333 ::sprintf(&ptr_deref_buffer[0], ptr_deref_format, index); 1334 if (log) 1335 log->Printf("[ExpandIndexedExpression] name to deref: %s",ptr_deref_buffer.c_str()); 1336 const char* first_unparsed; 1337 ValueObject::GetValueForExpressionPathOptions options; 1338 ValueObject::ExpressionPathEndResultType final_value_type; 1339 ValueObject::ExpressionPathScanEndReason reason_to_stop; 1340 ValueObject::ExpressionPathAftermath what_next = (deref_pointer ? ValueObject::eExpressionPathAftermathDereference : ValueObject::eExpressionPathAftermathNothing); 1341 ValueObjectSP item = valobj->GetValueForExpressionPath (ptr_deref_buffer.c_str(), 1342 &first_unparsed, 1343 &reason_to_stop, 1344 &final_value_type, 1345 options, 1346 &what_next); 1347 if (!item) 1348 { 1349 if (log) 1350 log->Printf("[ExpandIndexedExpression] ERROR: unparsed portion = %s, why stopping = %d," 1351 " final_value_type %d", 1352 first_unparsed, reason_to_stop, final_value_type); 1353 } 1354 else 1355 { 1356 if (log) 1357 log->Printf("[ExpandIndexedExpression] ALL RIGHT: unparsed portion = %s, why stopping = %d," 1358 " final_value_type %d", 1359 first_unparsed, reason_to_stop, final_value_type); 1360 } 1361 return item; 1362 } 1363 1364 static bool 1365 FormatPromptRecurse 1366 ( 1367 const char *format, 1368 const SymbolContext *sc, 1369 const ExecutionContext *exe_ctx, 1370 const Address *addr, 1371 Stream &s, 1372 const char **end, 1373 ValueObject* valobj 1374 ) 1375 { 1376 ValueObject* realvalobj = NULL; // makes it super-easy to parse pointers 1377 bool success = true; 1378 const char *p; 1379 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 1380 1381 for (p = format; *p != '\0'; ++p) 1382 { 1383 if (realvalobj) 1384 { 1385 valobj = realvalobj; 1386 realvalobj = NULL; 1387 } 1388 size_t non_special_chars = ::strcspn (p, "${}\\"); 1389 if (non_special_chars > 0) 1390 { 1391 if (success) 1392 s.Write (p, non_special_chars); 1393 p += non_special_chars; 1394 } 1395 1396 if (*p == '\0') 1397 { 1398 break; 1399 } 1400 else if (*p == '{') 1401 { 1402 // Start a new scope that must have everything it needs if it is to 1403 // to make it into the final output stream "s". If you want to make 1404 // a format that only prints out the function or symbol name if there 1405 // is one in the symbol context you can use: 1406 // "{function =${function.name}}" 1407 // The first '{' starts a new scope that end with the matching '}' at 1408 // the end of the string. The contents "function =${function.name}" 1409 // will then be evaluated and only be output if there is a function 1410 // or symbol with a valid name. 1411 StreamString sub_strm; 1412 1413 ++p; // Skip the '{' 1414 1415 if (FormatPromptRecurse (p, sc, exe_ctx, addr, sub_strm, &p, valobj)) 1416 { 1417 // The stream had all it needed 1418 s.Write(sub_strm.GetData(), sub_strm.GetSize()); 1419 } 1420 if (*p != '}') 1421 { 1422 success = false; 1423 break; 1424 } 1425 } 1426 else if (*p == '}') 1427 { 1428 // End of a enclosing scope 1429 break; 1430 } 1431 else if (*p == '$') 1432 { 1433 // We have a prompt variable to print 1434 ++p; 1435 if (*p == '{') 1436 { 1437 ++p; 1438 const char *var_name_begin = p; 1439 const char *var_name_end = ::strchr (p, '}'); 1440 1441 if (var_name_end && var_name_begin < var_name_end) 1442 { 1443 // if we have already failed to parse, skip this variable 1444 if (success) 1445 { 1446 const char *cstr = NULL; 1447 Address format_addr; 1448 bool calculate_format_addr_function_offset = false; 1449 // Set reg_kind and reg_num to invalid values 1450 RegisterKind reg_kind = kNumRegisterKinds; 1451 uint32_t reg_num = LLDB_INVALID_REGNUM; 1452 FileSpec format_file_spec; 1453 const RegisterInfo *reg_info = NULL; 1454 RegisterContext *reg_ctx = NULL; 1455 bool do_deref_pointer = false; 1456 ValueObject::ExpressionPathScanEndReason reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString; 1457 ValueObject::ExpressionPathEndResultType final_value_type = ValueObject::eExpressionPathEndResultTypePlain; 1458 1459 // Each variable must set success to true below... 1460 bool var_success = false; 1461 switch (var_name_begin[0]) 1462 { 1463 case '*': 1464 case 'v': 1465 case 's': 1466 { 1467 if (!valobj) 1468 break; 1469 1470 if (log) 1471 log->Printf("[Debugger::FormatPrompt] initial string: %s",var_name_begin); 1472 1473 // check for *var and *svar 1474 if (*var_name_begin == '*') 1475 { 1476 do_deref_pointer = true; 1477 var_name_begin++; 1478 if (log) 1479 log->Printf("[Debugger::FormatPrompt] found a deref, new string is: %s",var_name_begin); 1480 } 1481 1482 if (*var_name_begin == 's') 1483 { 1484 if (!valobj->IsSynthetic()) 1485 valobj = valobj->GetSyntheticValue().get(); 1486 if (!valobj) 1487 break; 1488 var_name_begin++; 1489 if (log) 1490 log->Printf("[Debugger::FormatPrompt] found a synthetic, new string is: %s",var_name_begin); 1491 } 1492 1493 // should be a 'v' by now 1494 if (*var_name_begin != 'v') 1495 break; 1496 1497 if (log) 1498 log->Printf("[Debugger::FormatPrompt] string I am working with: %s",var_name_begin); 1499 1500 ValueObject::ExpressionPathAftermath what_next = (do_deref_pointer ? 1501 ValueObject::eExpressionPathAftermathDereference : ValueObject::eExpressionPathAftermathNothing); 1502 ValueObject::GetValueForExpressionPathOptions options; 1503 options.DontCheckDotVsArrowSyntax().DoAllowBitfieldSyntax().DoAllowFragileIVar().DoAllowSyntheticChildren(); 1504 ValueObject::ValueObjectRepresentationStyle val_obj_display = ValueObject::eValueObjectRepresentationStyleSummary; 1505 ValueObject* target = NULL; 1506 Format custom_format = eFormatInvalid; 1507 const char* var_name_final = NULL; 1508 const char* var_name_final_if_array_range = NULL; 1509 const char* close_bracket_position = NULL; 1510 int64_t index_lower = -1; 1511 int64_t index_higher = -1; 1512 bool is_array_range = false; 1513 const char* first_unparsed; 1514 bool was_plain_var = false; 1515 bool was_var_format = false; 1516 bool was_var_indexed = false; 1517 1518 if (!valobj) break; 1519 // simplest case ${var}, just print valobj's value 1520 if (::strncmp (var_name_begin, "var}", strlen("var}")) == 0) 1521 { 1522 was_plain_var = true; 1523 target = valobj; 1524 val_obj_display = ValueObject::eValueObjectRepresentationStyleValue; 1525 } 1526 else if (::strncmp(var_name_begin,"var%",strlen("var%")) == 0) 1527 { 1528 was_var_format = true; 1529 // this is a variable with some custom format applied to it 1530 const char* percent_position; 1531 target = valobj; 1532 val_obj_display = ValueObject::eValueObjectRepresentationStyleValue; 1533 ScanFormatDescriptor (var_name_begin, 1534 var_name_end, 1535 &var_name_final, 1536 &percent_position, 1537 &custom_format, 1538 &val_obj_display); 1539 } 1540 // this is ${var.something} or multiple .something nested 1541 else if (::strncmp (var_name_begin, "var", strlen("var")) == 0) 1542 { 1543 if (::strncmp(var_name_begin, "var[", strlen("var[")) == 0) 1544 was_var_indexed = true; 1545 const char* percent_position; 1546 ScanFormatDescriptor (var_name_begin, 1547 var_name_end, 1548 &var_name_final, 1549 &percent_position, 1550 &custom_format, 1551 &val_obj_display); 1552 1553 const char* open_bracket_position; 1554 const char* separator_position; 1555 ScanBracketedRange (var_name_begin, 1556 var_name_end, 1557 var_name_final, 1558 &open_bracket_position, 1559 &separator_position, 1560 &close_bracket_position, 1561 &var_name_final_if_array_range, 1562 &index_lower, 1563 &index_higher); 1564 1565 Error error; 1566 1567 std::string expr_path(var_name_final-var_name_begin-1,0); 1568 memcpy(&expr_path[0], var_name_begin+3,var_name_final-var_name_begin-3); 1569 1570 if (log) 1571 log->Printf("[Debugger::FormatPrompt] symbol to expand: %s",expr_path.c_str()); 1572 1573 target = valobj->GetValueForExpressionPath(expr_path.c_str(), 1574 &first_unparsed, 1575 &reason_to_stop, 1576 &final_value_type, 1577 options, 1578 &what_next).get(); 1579 1580 if (!target) 1581 { 1582 if (log) 1583 log->Printf("[Debugger::FormatPrompt] ERROR: unparsed portion = %s, why stopping = %d," 1584 " final_value_type %d", 1585 first_unparsed, reason_to_stop, final_value_type); 1586 break; 1587 } 1588 else 1589 { 1590 if (log) 1591 log->Printf("[Debugger::FormatPrompt] ALL RIGHT: unparsed portion = %s, why stopping = %d," 1592 " final_value_type %d", 1593 first_unparsed, reason_to_stop, final_value_type); 1594 } 1595 } 1596 else 1597 break; 1598 1599 is_array_range = (final_value_type == ValueObject::eExpressionPathEndResultTypeBoundedRange || 1600 final_value_type == ValueObject::eExpressionPathEndResultTypeUnboundedRange); 1601 1602 do_deref_pointer = (what_next == ValueObject::eExpressionPathAftermathDereference); 1603 1604 if (do_deref_pointer && !is_array_range) 1605 { 1606 // I have not deref-ed yet, let's do it 1607 // this happens when we are not going through GetValueForVariableExpressionPath 1608 // to get to the target ValueObject 1609 Error error; 1610 target = target->Dereference(error).get(); 1611 if (error.Fail()) 1612 { 1613 if (log) 1614 log->Printf("[Debugger::FormatPrompt] ERROR: %s\n", error.AsCString("unknown")); \ 1615 break; 1616 } 1617 do_deref_pointer = false; 1618 } 1619 1620 // <rdar://problem/11338654> 1621 // we do not want to use the summary for a bitfield of type T:n 1622 // if we were originally dealing with just a T - that would get 1623 // us into an endless recursion 1624 if (target->IsBitfield() && was_var_indexed) 1625 { 1626 // TODO: check for a (T:n)-specific summary - we should still obey that 1627 StreamString bitfield_name; 1628 bitfield_name.Printf("%s:%d", target->GetTypeName().AsCString(), target->GetBitfieldBitSize()); 1629 lldb::TypeNameSpecifierImplSP type_sp(new TypeNameSpecifierImpl(bitfield_name.GetData(),false)); 1630 if (!DataVisualization::GetSummaryForType(type_sp)) 1631 val_obj_display = ValueObject::eValueObjectRepresentationStyleValue; 1632 } 1633 1634 // TODO use flags for these 1635 const uint32_t type_info_flags = target->GetClangType().GetTypeInfo(NULL); 1636 bool is_array = (type_info_flags & ClangASTType::eTypeIsArray) != 0; 1637 bool is_pointer = (type_info_flags & ClangASTType::eTypeIsPointer) != 0; 1638 bool is_aggregate = target->GetClangType().IsAggregateType(); 1639 1640 if ((is_array || is_pointer) && (!is_array_range) && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) // this should be wrong, but there are some exceptions 1641 { 1642 StreamString str_temp; 1643 if (log) 1644 log->Printf("[Debugger::FormatPrompt] I am into array || pointer && !range"); 1645 1646 if (target->HasSpecialPrintableRepresentation(val_obj_display, custom_format)) 1647 { 1648 // try to use the special cases 1649 var_success = target->DumpPrintableRepresentation(str_temp, 1650 val_obj_display, 1651 custom_format); 1652 if (log) 1653 log->Printf("[Debugger::FormatPrompt] special cases did%s match", var_success ? "" : "n't"); 1654 1655 // should not happen 1656 if (var_success) 1657 s << str_temp.GetData(); 1658 var_success = true; 1659 break; 1660 } 1661 else 1662 { 1663 if (was_plain_var) // if ${var} 1664 { 1665 s << target->GetTypeName() << " @ " << target->GetLocationAsCString(); 1666 } 1667 else if (is_pointer) // if pointer, value is the address stored 1668 { 1669 target->DumpPrintableRepresentation (s, 1670 val_obj_display, 1671 custom_format, 1672 ValueObject::ePrintableRepresentationSpecialCasesDisable); 1673 } 1674 var_success = true; 1675 break; 1676 } 1677 } 1678 1679 // if directly trying to print ${var}, and this is an aggregate, display a nice 1680 // type @ location message 1681 if (is_aggregate && was_plain_var) 1682 { 1683 s << target->GetTypeName() << " @ " << target->GetLocationAsCString(); 1684 var_success = true; 1685 break; 1686 } 1687 1688 // if directly trying to print ${var%V}, and this is an aggregate, do not let the user do it 1689 if (is_aggregate && ((was_var_format && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue))) 1690 { 1691 s << "<invalid use of aggregate type>"; 1692 var_success = true; 1693 break; 1694 } 1695 1696 if (!is_array_range) 1697 { 1698 if (log) 1699 log->Printf("[Debugger::FormatPrompt] dumping ordinary printable output"); 1700 var_success = target->DumpPrintableRepresentation(s,val_obj_display, custom_format); 1701 } 1702 else 1703 { 1704 if (log) 1705 log->Printf("[Debugger::FormatPrompt] checking if I can handle as array"); 1706 if (!is_array && !is_pointer) 1707 break; 1708 if (log) 1709 log->Printf("[Debugger::FormatPrompt] handle as array"); 1710 const char* special_directions = NULL; 1711 StreamString special_directions_writer; 1712 if (close_bracket_position && (var_name_end-close_bracket_position > 1)) 1713 { 1714 ConstString additional_data; 1715 additional_data.SetCStringWithLength(close_bracket_position+1, var_name_end-close_bracket_position-1); 1716 special_directions_writer.Printf("${%svar%s}", 1717 do_deref_pointer ? "*" : "", 1718 additional_data.GetCString()); 1719 special_directions = special_directions_writer.GetData(); 1720 } 1721 1722 // let us display items index_lower thru index_higher of this array 1723 s.PutChar('['); 1724 var_success = true; 1725 1726 if (index_higher < 0) 1727 index_higher = valobj->GetNumChildren() - 1; 1728 1729 uint32_t max_num_children = target->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); 1730 1731 for (;index_lower<=index_higher;index_lower++) 1732 { 1733 ValueObject* item = ExpandIndexedExpression (target, 1734 index_lower, 1735 exe_ctx->GetFramePtr(), 1736 false).get(); 1737 1738 if (!item) 1739 { 1740 if (log) 1741 log->Printf("[Debugger::FormatPrompt] ERROR in getting child item at index %" PRId64, index_lower); 1742 } 1743 else 1744 { 1745 if (log) 1746 log->Printf("[Debugger::FormatPrompt] special_directions for child item: %s",special_directions); 1747 } 1748 1749 if (!special_directions) 1750 var_success &= item->DumpPrintableRepresentation(s,val_obj_display, custom_format); 1751 else 1752 var_success &= FormatPromptRecurse(special_directions, sc, exe_ctx, addr, s, NULL, item); 1753 1754 if (--max_num_children == 0) 1755 { 1756 s.PutCString(", ..."); 1757 break; 1758 } 1759 1760 if (index_lower < index_higher) 1761 s.PutChar(','); 1762 } 1763 s.PutChar(']'); 1764 } 1765 } 1766 break; 1767 case 'a': 1768 if (::strncmp (var_name_begin, "addr}", strlen("addr}")) == 0) 1769 { 1770 if (addr && addr->IsValid()) 1771 { 1772 var_success = true; 1773 format_addr = *addr; 1774 } 1775 } 1776 break; 1777 1778 case 'p': 1779 if (::strncmp (var_name_begin, "process.", strlen("process.")) == 0) 1780 { 1781 if (exe_ctx) 1782 { 1783 Process *process = exe_ctx->GetProcessPtr(); 1784 if (process) 1785 { 1786 var_name_begin += ::strlen ("process."); 1787 if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0) 1788 { 1789 s.Printf("%" PRIu64, process->GetID()); 1790 var_success = true; 1791 } 1792 else if ((::strncmp (var_name_begin, "name}", strlen("name}")) == 0) || 1793 (::strncmp (var_name_begin, "file.basename}", strlen("file.basename}")) == 0) || 1794 (::strncmp (var_name_begin, "file.fullpath}", strlen("file.fullpath}")) == 0)) 1795 { 1796 Module *exe_module = process->GetTarget().GetExecutableModulePointer(); 1797 if (exe_module) 1798 { 1799 if (var_name_begin[0] == 'n' || var_name_begin[5] == 'f') 1800 { 1801 format_file_spec.GetFilename() = exe_module->GetFileSpec().GetFilename(); 1802 var_success = format_file_spec; 1803 } 1804 else 1805 { 1806 format_file_spec = exe_module->GetFileSpec(); 1807 var_success = format_file_spec; 1808 } 1809 } 1810 } 1811 else if (::strncmp(var_name_begin, "script:", strlen("script:")) == 0) 1812 { 1813 var_name_begin += ::strlen("script:"); 1814 std::string script_name(var_name_begin,var_name_end); 1815 ScriptInterpreter* script_interpreter = process->GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 1816 if (script_interpreter) 1817 { 1818 std::string script_output; 1819 Error script_error; 1820 if (script_interpreter->RunScriptFormatKeyword(script_name.c_str(), process,script_output,script_error) && script_error.Success()) 1821 { 1822 s.Printf("%s", script_output.c_str()); 1823 var_success = true; 1824 } 1825 else 1826 s.Printf("<error: %s>",script_error.AsCString()); 1827 } 1828 } 1829 } 1830 } 1831 } 1832 break; 1833 1834 case 't': 1835 if (::strncmp (var_name_begin, "thread.", strlen("thread.")) == 0) 1836 { 1837 if (exe_ctx) 1838 { 1839 Thread *thread = exe_ctx->GetThreadPtr(); 1840 if (thread) 1841 { 1842 var_name_begin += ::strlen ("thread."); 1843 if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0) 1844 { 1845 s.Printf("0x%4.4" PRIx64, thread->GetID()); 1846 var_success = true; 1847 } 1848 else if (::strncmp (var_name_begin, "protocol_id}", strlen("protocol_id}")) == 0) 1849 { 1850 s.Printf("0x%4.4" PRIx64, thread->GetProtocolID()); 1851 var_success = true; 1852 } 1853 else if (::strncmp (var_name_begin, "index}", strlen("index}")) == 0) 1854 { 1855 s.Printf("%u", thread->GetIndexID()); 1856 var_success = true; 1857 } 1858 else if (::strncmp (var_name_begin, "name}", strlen("name}")) == 0) 1859 { 1860 cstr = thread->GetName(); 1861 var_success = cstr && cstr[0]; 1862 if (var_success) 1863 s.PutCString(cstr); 1864 } 1865 else if (::strncmp (var_name_begin, "queue}", strlen("queue}")) == 0) 1866 { 1867 cstr = thread->GetQueueName(); 1868 var_success = cstr && cstr[0]; 1869 if (var_success) 1870 s.PutCString(cstr); 1871 } 1872 else if (::strncmp (var_name_begin, "stop-reason}", strlen("stop-reason}")) == 0) 1873 { 1874 StopInfoSP stop_info_sp = thread->GetStopInfo (); 1875 if (stop_info_sp && stop_info_sp->IsValid()) 1876 { 1877 cstr = stop_info_sp->GetDescription(); 1878 if (cstr && cstr[0]) 1879 { 1880 s.PutCString(cstr); 1881 var_success = true; 1882 } 1883 } 1884 } 1885 else if (::strncmp (var_name_begin, "return-value}", strlen("return-value}")) == 0) 1886 { 1887 StopInfoSP stop_info_sp = thread->GetStopInfo (); 1888 if (stop_info_sp && stop_info_sp->IsValid()) 1889 { 1890 ValueObjectSP return_valobj_sp = StopInfo::GetReturnValueObject (stop_info_sp); 1891 if (return_valobj_sp) 1892 { 1893 ValueObject::DumpValueObject (s, return_valobj_sp.get()); 1894 var_success = true; 1895 } 1896 } 1897 } 1898 else if (::strncmp(var_name_begin, "script:", strlen("script:")) == 0) 1899 { 1900 var_name_begin += ::strlen("script:"); 1901 std::string script_name(var_name_begin,var_name_end); 1902 ScriptInterpreter* script_interpreter = thread->GetProcess()->GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 1903 if (script_interpreter) 1904 { 1905 std::string script_output; 1906 Error script_error; 1907 if (script_interpreter->RunScriptFormatKeyword(script_name.c_str(), thread,script_output,script_error) && script_error.Success()) 1908 { 1909 s.Printf("%s", script_output.c_str()); 1910 var_success = true; 1911 } 1912 else 1913 s.Printf("<error: %s>",script_error.AsCString()); 1914 } 1915 } 1916 } 1917 } 1918 } 1919 else if (::strncmp (var_name_begin, "target.", strlen("target.")) == 0) 1920 { 1921 // TODO: hookup properties 1922 // if (!target_properties_sp) 1923 // { 1924 // Target *target = Target::GetTargetFromContexts (exe_ctx, sc); 1925 // if (target) 1926 // target_properties_sp = target->GetProperties(); 1927 // } 1928 // 1929 // if (target_properties_sp) 1930 // { 1931 // var_name_begin += ::strlen ("target."); 1932 // const char *end_property = strchr(var_name_begin, '}'); 1933 // if (end_property) 1934 // { 1935 // ConstString property_name(var_name_begin, end_property - var_name_begin); 1936 // std::string property_value (target_properties_sp->GetPropertyValue(property_name)); 1937 // if (!property_value.empty()) 1938 // { 1939 // s.PutCString (property_value.c_str()); 1940 // var_success = true; 1941 // } 1942 // } 1943 // } 1944 Target *target = Target::GetTargetFromContexts (exe_ctx, sc); 1945 if (target) 1946 { 1947 var_name_begin += ::strlen ("target."); 1948 if (::strncmp (var_name_begin, "arch}", strlen("arch}")) == 0) 1949 { 1950 ArchSpec arch (target->GetArchitecture ()); 1951 if (arch.IsValid()) 1952 { 1953 s.PutCString (arch.GetArchitectureName()); 1954 var_success = true; 1955 } 1956 } 1957 else if (::strncmp(var_name_begin, "script:", strlen("script:")) == 0) 1958 { 1959 var_name_begin += ::strlen("script:"); 1960 std::string script_name(var_name_begin,var_name_end); 1961 ScriptInterpreter* script_interpreter = target->GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 1962 if (script_interpreter) 1963 { 1964 std::string script_output; 1965 Error script_error; 1966 if (script_interpreter->RunScriptFormatKeyword(script_name.c_str(), target,script_output,script_error) && script_error.Success()) 1967 { 1968 s.Printf("%s", script_output.c_str()); 1969 var_success = true; 1970 } 1971 else 1972 s.Printf("<error: %s>",script_error.AsCString()); 1973 } 1974 } 1975 } 1976 } 1977 break; 1978 1979 1980 case 'm': 1981 if (::strncmp (var_name_begin, "module.", strlen("module.")) == 0) 1982 { 1983 if (sc && sc->module_sp.get()) 1984 { 1985 Module *module = sc->module_sp.get(); 1986 var_name_begin += ::strlen ("module."); 1987 1988 if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0) 1989 { 1990 if (module->GetFileSpec()) 1991 { 1992 var_name_begin += ::strlen ("file."); 1993 1994 if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0) 1995 { 1996 format_file_spec.GetFilename() = module->GetFileSpec().GetFilename(); 1997 var_success = format_file_spec; 1998 } 1999 else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0) 2000 { 2001 format_file_spec = module->GetFileSpec(); 2002 var_success = format_file_spec; 2003 } 2004 } 2005 } 2006 } 2007 } 2008 break; 2009 2010 2011 case 'f': 2012 if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0) 2013 { 2014 if (sc && sc->comp_unit != NULL) 2015 { 2016 var_name_begin += ::strlen ("file."); 2017 2018 if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0) 2019 { 2020 format_file_spec.GetFilename() = sc->comp_unit->GetFilename(); 2021 var_success = format_file_spec; 2022 } 2023 else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0) 2024 { 2025 format_file_spec = *sc->comp_unit; 2026 var_success = format_file_spec; 2027 } 2028 } 2029 } 2030 else if (::strncmp (var_name_begin, "frame.", strlen("frame.")) == 0) 2031 { 2032 if (exe_ctx) 2033 { 2034 StackFrame *frame = exe_ctx->GetFramePtr(); 2035 if (frame) 2036 { 2037 var_name_begin += ::strlen ("frame."); 2038 if (::strncmp (var_name_begin, "index}", strlen("index}")) == 0) 2039 { 2040 s.Printf("%u", frame->GetFrameIndex()); 2041 var_success = true; 2042 } 2043 else if (::strncmp (var_name_begin, "pc}", strlen("pc}")) == 0) 2044 { 2045 reg_kind = eRegisterKindGeneric; 2046 reg_num = LLDB_REGNUM_GENERIC_PC; 2047 var_success = true; 2048 } 2049 else if (::strncmp (var_name_begin, "sp}", strlen("sp}")) == 0) 2050 { 2051 reg_kind = eRegisterKindGeneric; 2052 reg_num = LLDB_REGNUM_GENERIC_SP; 2053 var_success = true; 2054 } 2055 else if (::strncmp (var_name_begin, "fp}", strlen("fp}")) == 0) 2056 { 2057 reg_kind = eRegisterKindGeneric; 2058 reg_num = LLDB_REGNUM_GENERIC_FP; 2059 var_success = true; 2060 } 2061 else if (::strncmp (var_name_begin, "flags}", strlen("flags}")) == 0) 2062 { 2063 reg_kind = eRegisterKindGeneric; 2064 reg_num = LLDB_REGNUM_GENERIC_FLAGS; 2065 var_success = true; 2066 } 2067 else if (::strncmp (var_name_begin, "reg.", strlen ("reg.")) == 0) 2068 { 2069 reg_ctx = frame->GetRegisterContext().get(); 2070 if (reg_ctx) 2071 { 2072 var_name_begin += ::strlen ("reg."); 2073 if (var_name_begin < var_name_end) 2074 { 2075 std::string reg_name (var_name_begin, var_name_end); 2076 reg_info = reg_ctx->GetRegisterInfoByName (reg_name.c_str()); 2077 if (reg_info) 2078 var_success = true; 2079 } 2080 } 2081 } 2082 else if (::strncmp(var_name_begin, "script:", strlen("script:")) == 0) 2083 { 2084 var_name_begin += ::strlen("script:"); 2085 std::string script_name(var_name_begin,var_name_end); 2086 ScriptInterpreter* script_interpreter = frame->GetThread()->GetProcess()->GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 2087 if (script_interpreter) 2088 { 2089 std::string script_output; 2090 Error script_error; 2091 if (script_interpreter->RunScriptFormatKeyword(script_name.c_str(), frame,script_output,script_error) && script_error.Success()) 2092 { 2093 s.Printf("%s", script_output.c_str()); 2094 var_success = true; 2095 } 2096 else 2097 s.Printf("<error: %s>",script_error.AsCString()); 2098 } 2099 } 2100 } 2101 } 2102 } 2103 else if (::strncmp (var_name_begin, "function.", strlen("function.")) == 0) 2104 { 2105 if (sc && (sc->function != NULL || sc->symbol != NULL)) 2106 { 2107 var_name_begin += ::strlen ("function."); 2108 if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0) 2109 { 2110 if (sc->function) 2111 s.Printf("function{0x%8.8" PRIx64 "}", sc->function->GetID()); 2112 else 2113 s.Printf("symbol[%u]", sc->symbol->GetID()); 2114 2115 var_success = true; 2116 } 2117 else if (::strncmp (var_name_begin, "name}", strlen("name}")) == 0) 2118 { 2119 if (sc->function) 2120 cstr = sc->function->GetName().AsCString (NULL); 2121 else if (sc->symbol) 2122 cstr = sc->symbol->GetName().AsCString (NULL); 2123 if (cstr) 2124 { 2125 s.PutCString(cstr); 2126 2127 if (sc->block) 2128 { 2129 Block *inline_block = sc->block->GetContainingInlinedBlock (); 2130 if (inline_block) 2131 { 2132 const InlineFunctionInfo *inline_info = sc->block->GetInlinedFunctionInfo(); 2133 if (inline_info) 2134 { 2135 s.PutCString(" [inlined] "); 2136 inline_info->GetName().Dump(&s); 2137 } 2138 } 2139 } 2140 var_success = true; 2141 } 2142 } 2143 else if (::strncmp (var_name_begin, "name-with-args}", strlen("name-with-args}")) == 0) 2144 { 2145 // Print the function name with arguments in it 2146 2147 if (sc->function) 2148 { 2149 var_success = true; 2150 ExecutionContextScope *exe_scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL; 2151 cstr = sc->function->GetName().AsCString (NULL); 2152 if (cstr) 2153 { 2154 const InlineFunctionInfo *inline_info = NULL; 2155 VariableListSP variable_list_sp; 2156 bool get_function_vars = true; 2157 if (sc->block) 2158 { 2159 Block *inline_block = sc->block->GetContainingInlinedBlock (); 2160 2161 if (inline_block) 2162 { 2163 get_function_vars = false; 2164 inline_info = sc->block->GetInlinedFunctionInfo(); 2165 if (inline_info) 2166 variable_list_sp = inline_block->GetBlockVariableList (true); 2167 } 2168 } 2169 2170 if (get_function_vars) 2171 { 2172 variable_list_sp = sc->function->GetBlock(true).GetBlockVariableList (true); 2173 } 2174 2175 if (inline_info) 2176 { 2177 s.PutCString (cstr); 2178 s.PutCString (" [inlined] "); 2179 cstr = inline_info->GetName().GetCString(); 2180 } 2181 2182 VariableList args; 2183 if (variable_list_sp) 2184 variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument, args); 2185 if (args.GetSize() > 0) 2186 { 2187 const char *open_paren = strchr (cstr, '('); 2188 const char *close_paren = NULL; 2189 if (open_paren) 2190 { 2191 if (strncmp(open_paren, "(anonymous namespace)", strlen("(anonymous namespace)")) == 0) 2192 { 2193 open_paren = strchr (open_paren + strlen("(anonymous namespace)"), '('); 2194 if (open_paren) 2195 close_paren = strchr (open_paren, ')'); 2196 } 2197 else 2198 close_paren = strchr (open_paren, ')'); 2199 } 2200 2201 if (open_paren) 2202 s.Write(cstr, open_paren - cstr + 1); 2203 else 2204 { 2205 s.PutCString (cstr); 2206 s.PutChar ('('); 2207 } 2208 const size_t num_args = args.GetSize(); 2209 for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) 2210 { 2211 VariableSP var_sp (args.GetVariableAtIndex (arg_idx)); 2212 ValueObjectSP var_value_sp (ValueObjectVariable::Create (exe_scope, var_sp)); 2213 const char *var_name = var_value_sp->GetName().GetCString(); 2214 const char *var_value = var_value_sp->GetValueAsCString(); 2215 if (arg_idx > 0) 2216 s.PutCString (", "); 2217 if (var_value_sp->GetError().Success()) 2218 { 2219 if (var_value) 2220 s.Printf ("%s=%s", var_name, var_value); 2221 else 2222 s.Printf ("%s=%s at %s", var_name, var_value_sp->GetTypeName().GetCString(), var_value_sp->GetLocationAsCString()); 2223 } 2224 else 2225 s.Printf ("%s=<unavailable>", var_name); 2226 } 2227 2228 if (close_paren) 2229 s.PutCString (close_paren); 2230 else 2231 s.PutChar(')'); 2232 2233 } 2234 else 2235 { 2236 s.PutCString(cstr); 2237 } 2238 } 2239 } 2240 else if (sc->symbol) 2241 { 2242 cstr = sc->symbol->GetName().AsCString (NULL); 2243 if (cstr) 2244 { 2245 s.PutCString(cstr); 2246 var_success = true; 2247 } 2248 } 2249 } 2250 else if (::strncmp (var_name_begin, "addr-offset}", strlen("addr-offset}")) == 0) 2251 { 2252 var_success = addr != NULL; 2253 if (var_success) 2254 { 2255 format_addr = *addr; 2256 calculate_format_addr_function_offset = true; 2257 } 2258 } 2259 else if (::strncmp (var_name_begin, "line-offset}", strlen("line-offset}")) == 0) 2260 { 2261 var_success = sc->line_entry.range.GetBaseAddress().IsValid(); 2262 if (var_success) 2263 { 2264 format_addr = sc->line_entry.range.GetBaseAddress(); 2265 calculate_format_addr_function_offset = true; 2266 } 2267 } 2268 else if (::strncmp (var_name_begin, "pc-offset}", strlen("pc-offset}")) == 0) 2269 { 2270 StackFrame *frame = exe_ctx->GetFramePtr(); 2271 var_success = frame != NULL; 2272 if (var_success) 2273 { 2274 format_addr = frame->GetFrameCodeAddress(); 2275 calculate_format_addr_function_offset = true; 2276 } 2277 } 2278 } 2279 } 2280 break; 2281 2282 case 'l': 2283 if (::strncmp (var_name_begin, "line.", strlen("line.")) == 0) 2284 { 2285 if (sc && sc->line_entry.IsValid()) 2286 { 2287 var_name_begin += ::strlen ("line."); 2288 if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0) 2289 { 2290 var_name_begin += ::strlen ("file."); 2291 2292 if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0) 2293 { 2294 format_file_spec.GetFilename() = sc->line_entry.file.GetFilename(); 2295 var_success = format_file_spec; 2296 } 2297 else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0) 2298 { 2299 format_file_spec = sc->line_entry.file; 2300 var_success = format_file_spec; 2301 } 2302 } 2303 else if (::strncmp (var_name_begin, "number}", strlen("number}")) == 0) 2304 { 2305 var_success = true; 2306 s.Printf("%u", sc->line_entry.line); 2307 } 2308 else if ((::strncmp (var_name_begin, "start-addr}", strlen("start-addr}")) == 0) || 2309 (::strncmp (var_name_begin, "end-addr}", strlen("end-addr}")) == 0)) 2310 { 2311 var_success = sc && sc->line_entry.range.GetBaseAddress().IsValid(); 2312 if (var_success) 2313 { 2314 format_addr = sc->line_entry.range.GetBaseAddress(); 2315 if (var_name_begin[0] == 'e') 2316 format_addr.Slide (sc->line_entry.range.GetByteSize()); 2317 } 2318 } 2319 } 2320 } 2321 break; 2322 } 2323 2324 if (var_success) 2325 { 2326 // If format addr is valid, then we need to print an address 2327 if (reg_num != LLDB_INVALID_REGNUM) 2328 { 2329 StackFrame *frame = exe_ctx->GetFramePtr(); 2330 // We have a register value to display... 2331 if (reg_num == LLDB_REGNUM_GENERIC_PC && reg_kind == eRegisterKindGeneric) 2332 { 2333 format_addr = frame->GetFrameCodeAddress(); 2334 } 2335 else 2336 { 2337 if (reg_ctx == NULL) 2338 reg_ctx = frame->GetRegisterContext().get(); 2339 2340 if (reg_ctx) 2341 { 2342 if (reg_kind != kNumRegisterKinds) 2343 reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num); 2344 reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_num); 2345 var_success = reg_info != NULL; 2346 } 2347 } 2348 } 2349 2350 if (reg_info != NULL) 2351 { 2352 RegisterValue reg_value; 2353 var_success = reg_ctx->ReadRegister (reg_info, reg_value); 2354 if (var_success) 2355 { 2356 reg_value.Dump(&s, reg_info, false, false, eFormatDefault); 2357 } 2358 } 2359 2360 if (format_file_spec) 2361 { 2362 s << format_file_spec; 2363 } 2364 2365 // If format addr is valid, then we need to print an address 2366 if (format_addr.IsValid()) 2367 { 2368 var_success = false; 2369 2370 if (calculate_format_addr_function_offset) 2371 { 2372 Address func_addr; 2373 2374 if (sc) 2375 { 2376 if (sc->function) 2377 { 2378 func_addr = sc->function->GetAddressRange().GetBaseAddress(); 2379 if (sc->block) 2380 { 2381 // Check to make sure we aren't in an inline 2382 // function. If we are, use the inline block 2383 // range that contains "format_addr" since 2384 // blocks can be discontiguous. 2385 Block *inline_block = sc->block->GetContainingInlinedBlock (); 2386 AddressRange inline_range; 2387 if (inline_block && inline_block->GetRangeContainingAddress (format_addr, inline_range)) 2388 func_addr = inline_range.GetBaseAddress(); 2389 } 2390 } 2391 else if (sc->symbol && sc->symbol->ValueIsAddress()) 2392 func_addr = sc->symbol->GetAddress(); 2393 } 2394 2395 if (func_addr.IsValid()) 2396 { 2397 if (func_addr.GetSection() == format_addr.GetSection()) 2398 { 2399 addr_t func_file_addr = func_addr.GetFileAddress(); 2400 addr_t addr_file_addr = format_addr.GetFileAddress(); 2401 if (addr_file_addr > func_file_addr) 2402 s.Printf(" + %" PRIu64, addr_file_addr - func_file_addr); 2403 else if (addr_file_addr < func_file_addr) 2404 s.Printf(" - %" PRIu64, func_file_addr - addr_file_addr); 2405 var_success = true; 2406 } 2407 else 2408 { 2409 Target *target = Target::GetTargetFromContexts (exe_ctx, sc); 2410 if (target) 2411 { 2412 addr_t func_load_addr = func_addr.GetLoadAddress (target); 2413 addr_t addr_load_addr = format_addr.GetLoadAddress (target); 2414 if (addr_load_addr > func_load_addr) 2415 s.Printf(" + %" PRIu64, addr_load_addr - func_load_addr); 2416 else if (addr_load_addr < func_load_addr) 2417 s.Printf(" - %" PRIu64, func_load_addr - addr_load_addr); 2418 var_success = true; 2419 } 2420 } 2421 } 2422 } 2423 else 2424 { 2425 Target *target = Target::GetTargetFromContexts (exe_ctx, sc); 2426 addr_t vaddr = LLDB_INVALID_ADDRESS; 2427 if (exe_ctx && !target->GetSectionLoadList().IsEmpty()) 2428 vaddr = format_addr.GetLoadAddress (target); 2429 if (vaddr == LLDB_INVALID_ADDRESS) 2430 vaddr = format_addr.GetFileAddress (); 2431 2432 if (vaddr != LLDB_INVALID_ADDRESS) 2433 { 2434 int addr_width = target->GetArchitecture().GetAddressByteSize() * 2; 2435 if (addr_width == 0) 2436 addr_width = 16; 2437 s.Printf("0x%*.*" PRIx64, addr_width, addr_width, vaddr); 2438 var_success = true; 2439 } 2440 } 2441 } 2442 } 2443 2444 if (var_success == false) 2445 success = false; 2446 } 2447 p = var_name_end; 2448 } 2449 else 2450 break; 2451 } 2452 else 2453 { 2454 // We got a dollar sign with no '{' after it, it must just be a dollar sign 2455 s.PutChar(*p); 2456 } 2457 } 2458 else if (*p == '\\') 2459 { 2460 ++p; // skip the slash 2461 switch (*p) 2462 { 2463 case 'a': s.PutChar ('\a'); break; 2464 case 'b': s.PutChar ('\b'); break; 2465 case 'f': s.PutChar ('\f'); break; 2466 case 'n': s.PutChar ('\n'); break; 2467 case 'r': s.PutChar ('\r'); break; 2468 case 't': s.PutChar ('\t'); break; 2469 case 'v': s.PutChar ('\v'); break; 2470 case '\'': s.PutChar ('\''); break; 2471 case '\\': s.PutChar ('\\'); break; 2472 case '0': 2473 // 1 to 3 octal chars 2474 { 2475 // Make a string that can hold onto the initial zero char, 2476 // up to 3 octal digits, and a terminating NULL. 2477 char oct_str[5] = { 0, 0, 0, 0, 0 }; 2478 2479 int i; 2480 for (i=0; (p[i] >= '0' && p[i] <= '7') && i<4; ++i) 2481 oct_str[i] = p[i]; 2482 2483 // We don't want to consume the last octal character since 2484 // the main for loop will do this for us, so we advance p by 2485 // one less than i (even if i is zero) 2486 p += i - 1; 2487 unsigned long octal_value = ::strtoul (oct_str, NULL, 8); 2488 if (octal_value <= UINT8_MAX) 2489 { 2490 s.PutChar((char)octal_value); 2491 } 2492 } 2493 break; 2494 2495 case 'x': 2496 // hex number in the format 2497 if (isxdigit(p[1])) 2498 { 2499 ++p; // Skip the 'x' 2500 2501 // Make a string that can hold onto two hex chars plus a 2502 // NULL terminator 2503 char hex_str[3] = { 0,0,0 }; 2504 hex_str[0] = *p; 2505 if (isxdigit(p[1])) 2506 { 2507 ++p; // Skip the first of the two hex chars 2508 hex_str[1] = *p; 2509 } 2510 2511 unsigned long hex_value = strtoul (hex_str, NULL, 16); 2512 if (hex_value <= UINT8_MAX) 2513 s.PutChar ((char)hex_value); 2514 } 2515 else 2516 { 2517 s.PutChar('x'); 2518 } 2519 break; 2520 2521 default: 2522 // Just desensitize any other character by just printing what 2523 // came after the '\' 2524 s << *p; 2525 break; 2526 2527 } 2528 2529 } 2530 } 2531 if (end) 2532 *end = p; 2533 return success; 2534 } 2535 2536 bool 2537 Debugger::FormatPrompt 2538 ( 2539 const char *format, 2540 const SymbolContext *sc, 2541 const ExecutionContext *exe_ctx, 2542 const Address *addr, 2543 Stream &s, 2544 ValueObject* valobj 2545 ) 2546 { 2547 bool use_color = exe_ctx ? exe_ctx->GetTargetRef().GetDebugger().GetUseColor() : true; 2548 std::string format_str = lldb_utility::ansi::FormatAnsiTerminalCodes (format, use_color); 2549 if (format_str.length()) 2550 format = format_str.c_str(); 2551 return FormatPromptRecurse (format, sc, exe_ctx, addr, s, NULL, valobj); 2552 } 2553 2554 void 2555 Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 2556 { 2557 // For simplicity's sake, I am not going to deal with how to close down any 2558 // open logging streams, I just redirect everything from here on out to the 2559 // callback. 2560 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton)); 2561 } 2562 2563 bool 2564 Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream) 2565 { 2566 Log::Callbacks log_callbacks; 2567 2568 StreamSP log_stream_sp; 2569 if (m_log_callback_stream_sp) 2570 { 2571 log_stream_sp = m_log_callback_stream_sp; 2572 // For now when using the callback mode you always get thread & timestamp. 2573 log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 2574 } 2575 else if (log_file == NULL || *log_file == '\0') 2576 { 2577 log_stream_sp.reset(new StreamFile(GetOutputFile().GetDescriptor(), false)); 2578 } 2579 else 2580 { 2581 LogStreamMap::iterator pos = m_log_streams.find(log_file); 2582 if (pos != m_log_streams.end()) 2583 log_stream_sp = pos->second.lock(); 2584 if (!log_stream_sp) 2585 { 2586 log_stream_sp.reset (new StreamFile (log_file)); 2587 m_log_streams[log_file] = log_stream_sp; 2588 } 2589 } 2590 assert (log_stream_sp.get()); 2591 2592 if (log_options == 0) 2593 log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE; 2594 2595 if (Log::GetLogChannelCallbacks (ConstString(channel), log_callbacks)) 2596 { 2597 log_callbacks.enable (log_stream_sp, log_options, categories, &error_stream); 2598 return true; 2599 } 2600 else 2601 { 2602 LogChannelSP log_channel_sp (LogChannel::FindPlugin (channel)); 2603 if (log_channel_sp) 2604 { 2605 if (log_channel_sp->Enable (log_stream_sp, log_options, &error_stream, categories)) 2606 { 2607 return true; 2608 } 2609 else 2610 { 2611 error_stream.Printf ("Invalid log channel '%s'.\n", channel); 2612 return false; 2613 } 2614 } 2615 else 2616 { 2617 error_stream.Printf ("Invalid log channel '%s'.\n", channel); 2618 return false; 2619 } 2620 } 2621 return false; 2622 } 2623 2624 SourceManager & 2625 Debugger::GetSourceManager () 2626 { 2627 if (m_source_manager_ap.get() == NULL) 2628 m_source_manager_ap.reset (new SourceManager (shared_from_this())); 2629 return *m_source_manager_ap; 2630 } 2631 2632 2633