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