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