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