Target.cpp revision 269024
1//===-- Target.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/Target/Target.h" 13 14// C Includes 15// C++ Includes 16// Other libraries and framework includes 17// Project includes 18#include "lldb/Breakpoint/BreakpointResolver.h" 19#include "lldb/Breakpoint/BreakpointResolverAddress.h" 20#include "lldb/Breakpoint/BreakpointResolverFileLine.h" 21#include "lldb/Breakpoint/BreakpointResolverFileRegex.h" 22#include "lldb/Breakpoint/BreakpointResolverName.h" 23#include "lldb/Breakpoint/Watchpoint.h" 24#include "lldb/Core/Debugger.h" 25#include "lldb/Core/Event.h" 26#include "lldb/Core/Log.h" 27#include "lldb/Core/Module.h" 28#include "lldb/Core/ModuleSpec.h" 29#include "lldb/Core/Section.h" 30#include "lldb/Core/SourceManager.h" 31#include "lldb/Core/State.h" 32#include "lldb/Core/StreamFile.h" 33#include "lldb/Core/StreamString.h" 34#include "lldb/Core/Timer.h" 35#include "lldb/Core/ValueObject.h" 36#include "lldb/Expression/ClangASTSource.h" 37#include "lldb/Expression/ClangUserExpression.h" 38#include "lldb/Host/Host.h" 39#include "lldb/Interpreter/CommandInterpreter.h" 40#include "lldb/Interpreter/CommandReturnObject.h" 41#include "lldb/Interpreter/OptionGroupWatchpoint.h" 42#include "lldb/Interpreter/OptionValues.h" 43#include "lldb/Interpreter/Property.h" 44#include "lldb/lldb-private-log.h" 45#include "lldb/Symbol/ObjectFile.h" 46#include "lldb/Target/Process.h" 47#include "lldb/Target/SectionLoadList.h" 48#include "lldb/Target/StackFrame.h" 49#include "lldb/Target/SystemRuntime.h" 50#include "lldb/Target/Thread.h" 51#include "lldb/Target/ThreadSpec.h" 52 53using namespace lldb; 54using namespace lldb_private; 55 56ConstString & 57Target::GetStaticBroadcasterClass () 58{ 59 static ConstString class_name ("lldb.target"); 60 return class_name; 61} 62 63//---------------------------------------------------------------------- 64// Target constructor 65//---------------------------------------------------------------------- 66Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp) : 67 TargetProperties (this), 68 Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()), 69 ExecutionContextScope (), 70 m_debugger (debugger), 71 m_platform_sp (platform_sp), 72 m_mutex (Mutex::eMutexTypeRecursive), 73 m_arch (target_arch), 74 m_images (this), 75 m_section_load_history (), 76 m_breakpoint_list (false), 77 m_internal_breakpoint_list (true), 78 m_watchpoint_list (), 79 m_process_sp (), 80 m_search_filter_sp (), 81 m_image_search_paths (ImageSearchPathsChanged, this), 82 m_scratch_ast_context_ap (), 83 m_scratch_ast_source_ap (), 84 m_ast_importer_ap (), 85 m_persistent_variables (), 86 m_source_manager_ap(), 87 m_stop_hooks (), 88 m_stop_hook_next_id (0), 89 m_valid (true), 90 m_suppress_stop_hooks (false) 91{ 92 SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed"); 93 SetEventName (eBroadcastBitModulesLoaded, "modules-loaded"); 94 SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded"); 95 SetEventName (eBroadcastBitWatchpointChanged, "watchpoint-changed"); 96 SetEventName (eBroadcastBitSymbolsLoaded, "symbols-loaded"); 97 98 CheckInWithManager(); 99 100 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 101 if (log) 102 log->Printf ("%p Target::Target()", this); 103 if (m_arch.IsValid()) 104 { 105 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 106 } 107} 108 109//---------------------------------------------------------------------- 110// Destructor 111//---------------------------------------------------------------------- 112Target::~Target() 113{ 114 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 115 if (log) 116 log->Printf ("%p Target::~Target()", this); 117 DeleteCurrentProcess (); 118} 119 120void 121Target::Dump (Stream *s, lldb::DescriptionLevel description_level) 122{ 123// s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 124 if (description_level != lldb::eDescriptionLevelBrief) 125 { 126 s->Indent(); 127 s->PutCString("Target\n"); 128 s->IndentMore(); 129 m_images.Dump(s); 130 m_breakpoint_list.Dump(s); 131 m_internal_breakpoint_list.Dump(s); 132 s->IndentLess(); 133 } 134 else 135 { 136 Module *exe_module = GetExecutableModulePointer(); 137 if (exe_module) 138 s->PutCString (exe_module->GetFileSpec().GetFilename().GetCString()); 139 else 140 s->PutCString ("No executable module."); 141 } 142} 143 144void 145Target::CleanupProcess () 146{ 147 // Do any cleanup of the target we need to do between process instances. 148 // NB It is better to do this before destroying the process in case the 149 // clean up needs some help from the process. 150 m_breakpoint_list.ClearAllBreakpointSites(); 151 m_internal_breakpoint_list.ClearAllBreakpointSites(); 152 // Disable watchpoints just on the debugger side. 153 Mutex::Locker locker; 154 this->GetWatchpointList().GetListMutex(locker); 155 DisableAllWatchpoints(false); 156 ClearAllWatchpointHitCounts(); 157} 158 159void 160Target::DeleteCurrentProcess () 161{ 162 if (m_process_sp.get()) 163 { 164 m_section_load_history.Clear(); 165 if (m_process_sp->IsAlive()) 166 m_process_sp->Destroy(); 167 168 m_process_sp->Finalize(); 169 170 CleanupProcess (); 171 172 m_process_sp.reset(); 173 } 174} 175 176const lldb::ProcessSP & 177Target::CreateProcess (Listener &listener, const char *plugin_name, const FileSpec *crash_file) 178{ 179 DeleteCurrentProcess (); 180 m_process_sp = Process::FindPlugin(*this, plugin_name, listener, crash_file); 181 return m_process_sp; 182} 183 184const lldb::ProcessSP & 185Target::GetProcessSP () const 186{ 187 return m_process_sp; 188} 189 190void 191Target::Destroy() 192{ 193 Mutex::Locker locker (m_mutex); 194 m_valid = false; 195 DeleteCurrentProcess (); 196 m_platform_sp.reset(); 197 m_arch.Clear(); 198 ClearModules(true); 199 m_section_load_history.Clear(); 200 const bool notify = false; 201 m_breakpoint_list.RemoveAll(notify); 202 m_internal_breakpoint_list.RemoveAll(notify); 203 m_last_created_breakpoint.reset(); 204 m_last_created_watchpoint.reset(); 205 m_search_filter_sp.reset(); 206 m_image_search_paths.Clear(notify); 207 m_persistent_variables.Clear(); 208 m_stop_hooks.clear(); 209 m_stop_hook_next_id = 0; 210 m_suppress_stop_hooks = false; 211} 212 213 214BreakpointList & 215Target::GetBreakpointList(bool internal) 216{ 217 if (internal) 218 return m_internal_breakpoint_list; 219 else 220 return m_breakpoint_list; 221} 222 223const BreakpointList & 224Target::GetBreakpointList(bool internal) const 225{ 226 if (internal) 227 return m_internal_breakpoint_list; 228 else 229 return m_breakpoint_list; 230} 231 232BreakpointSP 233Target::GetBreakpointByID (break_id_t break_id) 234{ 235 BreakpointSP bp_sp; 236 237 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 238 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 239 else 240 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 241 242 return bp_sp; 243} 244 245BreakpointSP 246Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules, 247 const FileSpecList *source_file_spec_list, 248 RegularExpression &source_regex, 249 bool internal, 250 bool hardware) 251{ 252 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list)); 253 BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex (NULL, source_regex)); 254 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 255} 256 257 258BreakpointSP 259Target::CreateBreakpoint (const FileSpecList *containingModules, 260 const FileSpec &file, 261 uint32_t line_no, 262 LazyBool check_inlines, 263 LazyBool skip_prologue, 264 bool internal, 265 bool hardware) 266{ 267 if (check_inlines == eLazyBoolCalculate) 268 { 269 const InlineStrategy inline_strategy = GetInlineStrategy(); 270 switch (inline_strategy) 271 { 272 case eInlineBreakpointsNever: 273 check_inlines = eLazyBoolNo; 274 break; 275 276 case eInlineBreakpointsHeaders: 277 if (file.IsSourceImplementationFile()) 278 check_inlines = eLazyBoolNo; 279 else 280 check_inlines = eLazyBoolYes; 281 break; 282 283 case eInlineBreakpointsAlways: 284 check_inlines = eLazyBoolYes; 285 break; 286 } 287 } 288 SearchFilterSP filter_sp; 289 if (check_inlines == eLazyBoolNo) 290 { 291 // Not checking for inlines, we are looking only for matching compile units 292 FileSpecList compile_unit_list; 293 compile_unit_list.Append (file); 294 filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list); 295 } 296 else 297 { 298 filter_sp = GetSearchFilterForModuleList (containingModules); 299 } 300 if (skip_prologue == eLazyBoolCalculate) 301 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 302 303 BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (NULL, 304 file, 305 line_no, 306 check_inlines, 307 skip_prologue)); 308 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 309} 310 311 312BreakpointSP 313Target::CreateBreakpoint (lldb::addr_t addr, bool internal, bool hardware) 314{ 315 Address so_addr; 316 // Attempt to resolve our load address if possible, though it is ok if 317 // it doesn't resolve to section/offset. 318 319 // Try and resolve as a load address if possible 320 GetSectionLoadList().ResolveLoadAddress(addr, so_addr); 321 if (!so_addr.IsValid()) 322 { 323 // The address didn't resolve, so just set this as an absolute address 324 so_addr.SetOffset (addr); 325 } 326 BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal, hardware)); 327 return bp_sp; 328} 329 330BreakpointSP 331Target::CreateBreakpoint (Address &addr, bool internal, bool hardware) 332{ 333 SearchFilterSP filter_sp(new SearchFilterForNonModuleSpecificSearches (shared_from_this())); 334 BreakpointResolverSP resolver_sp (new BreakpointResolverAddress (NULL, addr)); 335 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, false); 336} 337 338BreakpointSP 339Target::CreateBreakpoint (const FileSpecList *containingModules, 340 const FileSpecList *containingSourceFiles, 341 const char *func_name, 342 uint32_t func_name_type_mask, 343 LazyBool skip_prologue, 344 bool internal, 345 bool hardware) 346{ 347 BreakpointSP bp_sp; 348 if (func_name) 349 { 350 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 351 352 if (skip_prologue == eLazyBoolCalculate) 353 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 354 355 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 356 func_name, 357 func_name_type_mask, 358 Breakpoint::Exact, 359 skip_prologue)); 360 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 361 } 362 return bp_sp; 363} 364 365lldb::BreakpointSP 366Target::CreateBreakpoint (const FileSpecList *containingModules, 367 const FileSpecList *containingSourceFiles, 368 const std::vector<std::string> &func_names, 369 uint32_t func_name_type_mask, 370 LazyBool skip_prologue, 371 bool internal, 372 bool hardware) 373{ 374 BreakpointSP bp_sp; 375 size_t num_names = func_names.size(); 376 if (num_names > 0) 377 { 378 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 379 380 if (skip_prologue == eLazyBoolCalculate) 381 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 382 383 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 384 func_names, 385 func_name_type_mask, 386 skip_prologue)); 387 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 388 } 389 return bp_sp; 390} 391 392BreakpointSP 393Target::CreateBreakpoint (const FileSpecList *containingModules, 394 const FileSpecList *containingSourceFiles, 395 const char *func_names[], 396 size_t num_names, 397 uint32_t func_name_type_mask, 398 LazyBool skip_prologue, 399 bool internal, 400 bool hardware) 401{ 402 BreakpointSP bp_sp; 403 if (num_names > 0) 404 { 405 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 406 407 if (skip_prologue == eLazyBoolCalculate) 408 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 409 410 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 411 func_names, 412 num_names, 413 func_name_type_mask, 414 skip_prologue)); 415 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 416 } 417 return bp_sp; 418} 419 420SearchFilterSP 421Target::GetSearchFilterForModule (const FileSpec *containingModule) 422{ 423 SearchFilterSP filter_sp; 424 if (containingModule != NULL) 425 { 426 // TODO: We should look into sharing module based search filters 427 // across many breakpoints like we do for the simple target based one 428 filter_sp.reset (new SearchFilterByModule (shared_from_this(), *containingModule)); 429 } 430 else 431 { 432 if (m_search_filter_sp.get() == NULL) 433 m_search_filter_sp.reset (new SearchFilterForNonModuleSpecificSearches (shared_from_this())); 434 filter_sp = m_search_filter_sp; 435 } 436 return filter_sp; 437} 438 439SearchFilterSP 440Target::GetSearchFilterForModuleList (const FileSpecList *containingModules) 441{ 442 SearchFilterSP filter_sp; 443 if (containingModules && containingModules->GetSize() != 0) 444 { 445 // TODO: We should look into sharing module based search filters 446 // across many breakpoints like we do for the simple target based one 447 filter_sp.reset (new SearchFilterByModuleList (shared_from_this(), *containingModules)); 448 } 449 else 450 { 451 if (m_search_filter_sp.get() == NULL) 452 m_search_filter_sp.reset (new SearchFilterForNonModuleSpecificSearches (shared_from_this())); 453 filter_sp = m_search_filter_sp; 454 } 455 return filter_sp; 456} 457 458SearchFilterSP 459Target::GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules, 460 const FileSpecList *containingSourceFiles) 461{ 462 if (containingSourceFiles == NULL || containingSourceFiles->GetSize() == 0) 463 return GetSearchFilterForModuleList(containingModules); 464 465 SearchFilterSP filter_sp; 466 if (containingModules == NULL) 467 { 468 // We could make a special "CU List only SearchFilter". Better yet was if these could be composable, 469 // but that will take a little reworking. 470 471 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), FileSpecList(), *containingSourceFiles)); 472 } 473 else 474 { 475 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), *containingModules, *containingSourceFiles)); 476 } 477 return filter_sp; 478} 479 480BreakpointSP 481Target::CreateFuncRegexBreakpoint (const FileSpecList *containingModules, 482 const FileSpecList *containingSourceFiles, 483 RegularExpression &func_regex, 484 LazyBool skip_prologue, 485 bool internal, 486 bool hardware) 487{ 488 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 489 BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL, 490 func_regex, 491 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); 492 493 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 494} 495 496lldb::BreakpointSP 497Target::CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal) 498{ 499 return LanguageRuntime::CreateExceptionBreakpoint (*this, language, catch_bp, throw_bp, internal); 500} 501 502BreakpointSP 503Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal, bool request_hardware, bool resolve_indirect_symbols) 504{ 505 BreakpointSP bp_sp; 506 if (filter_sp && resolver_sp) 507 { 508 bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp, request_hardware, resolve_indirect_symbols)); 509 resolver_sp->SetBreakpoint (bp_sp.get()); 510 511 if (internal) 512 m_internal_breakpoint_list.Add (bp_sp, false); 513 else 514 m_breakpoint_list.Add (bp_sp, true); 515 516 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 517 if (log) 518 { 519 StreamString s; 520 bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 521 log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, internal ? "yes" : "no", s.GetData()); 522 } 523 524 bp_sp->ResolveBreakpoint(); 525 } 526 527 if (!internal && bp_sp) 528 { 529 m_last_created_breakpoint = bp_sp; 530 } 531 532 return bp_sp; 533} 534 535bool 536Target::ProcessIsValid() 537{ 538 return (m_process_sp && m_process_sp->IsAlive()); 539} 540 541static bool 542CheckIfWatchpointsExhausted(Target *target, Error &error) 543{ 544 uint32_t num_supported_hardware_watchpoints; 545 Error rc = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints); 546 if (rc.Success()) 547 { 548 uint32_t num_current_watchpoints = target->GetWatchpointList().GetSize(); 549 if (num_current_watchpoints >= num_supported_hardware_watchpoints) 550 error.SetErrorStringWithFormat("number of supported hardware watchpoints (%u) has been reached", 551 num_supported_hardware_watchpoints); 552 } 553 return false; 554} 555 556// See also Watchpoint::SetWatchpointType(uint32_t type) and 557// the OptionGroupWatchpoint::WatchType enum type. 558WatchpointSP 559Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const ClangASTType *type, uint32_t kind, Error &error) 560{ 561 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 562 if (log) 563 log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64 " type = %u)\n", 564 __FUNCTION__, addr, (uint64_t)size, kind); 565 566 WatchpointSP wp_sp; 567 if (!ProcessIsValid()) 568 { 569 error.SetErrorString("process is not alive"); 570 return wp_sp; 571 } 572 573 if (addr == LLDB_INVALID_ADDRESS || size == 0) 574 { 575 if (size == 0) 576 error.SetErrorString("cannot set a watchpoint with watch_size of 0"); 577 else 578 error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr); 579 return wp_sp; 580 } 581 582 if (!LLDB_WATCH_TYPE_IS_VALID(kind)) 583 { 584 error.SetErrorStringWithFormat ("invalid watchpoint type: %d", kind); 585 } 586 587 // Currently we only support one watchpoint per address, with total number 588 // of watchpoints limited by the hardware which the inferior is running on. 589 590 // Grab the list mutex while doing operations. 591 const bool notify = false; // Don't notify about all the state changes we do on creating the watchpoint. 592 Mutex::Locker locker; 593 this->GetWatchpointList().GetListMutex(locker); 594 WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr); 595 if (matched_sp) 596 { 597 size_t old_size = matched_sp->GetByteSize(); 598 uint32_t old_type = 599 (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) | 600 (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0); 601 // Return the existing watchpoint if both size and type match. 602 if (size == old_size && kind == old_type) 603 { 604 wp_sp = matched_sp; 605 wp_sp->SetEnabled(false, notify); 606 } 607 else 608 { 609 // Nil the matched watchpoint; we will be creating a new one. 610 m_process_sp->DisableWatchpoint(matched_sp.get(), notify); 611 m_watchpoint_list.Remove(matched_sp->GetID(), true); 612 } 613 } 614 615 if (!wp_sp) 616 { 617 wp_sp.reset(new Watchpoint(*this, addr, size, type)); 618 wp_sp->SetWatchpointType(kind, notify); 619 m_watchpoint_list.Add (wp_sp, true); 620 } 621 622 error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify); 623 if (log) 624 log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n", 625 __FUNCTION__, 626 error.Success() ? "succeeded" : "failed", 627 wp_sp->GetID()); 628 629 if (error.Fail()) 630 { 631 // Enabling the watchpoint on the device side failed. 632 // Remove the said watchpoint from the list maintained by the target instance. 633 m_watchpoint_list.Remove (wp_sp->GetID(), true); 634 // See if we could provide more helpful error message. 635 if (!CheckIfWatchpointsExhausted(this, error)) 636 { 637 if (!OptionGroupWatchpoint::IsWatchSizeSupported(size)) 638 error.SetErrorStringWithFormat("watch size of %zu is not supported", size); 639 } 640 wp_sp.reset(); 641 } 642 else 643 m_last_created_watchpoint = wp_sp; 644 return wp_sp; 645} 646 647void 648Target::RemoveAllBreakpoints (bool internal_also) 649{ 650 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 651 if (log) 652 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 653 654 m_breakpoint_list.RemoveAll (true); 655 if (internal_also) 656 m_internal_breakpoint_list.RemoveAll (false); 657 658 m_last_created_breakpoint.reset(); 659} 660 661void 662Target::DisableAllBreakpoints (bool internal_also) 663{ 664 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 665 if (log) 666 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 667 668 m_breakpoint_list.SetEnabledAll (false); 669 if (internal_also) 670 m_internal_breakpoint_list.SetEnabledAll (false); 671} 672 673void 674Target::EnableAllBreakpoints (bool internal_also) 675{ 676 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 677 if (log) 678 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 679 680 m_breakpoint_list.SetEnabledAll (true); 681 if (internal_also) 682 m_internal_breakpoint_list.SetEnabledAll (true); 683} 684 685bool 686Target::RemoveBreakpointByID (break_id_t break_id) 687{ 688 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 689 if (log) 690 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 691 692 if (DisableBreakpointByID (break_id)) 693 { 694 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 695 m_internal_breakpoint_list.Remove(break_id, false); 696 else 697 { 698 if (m_last_created_breakpoint) 699 { 700 if (m_last_created_breakpoint->GetID() == break_id) 701 m_last_created_breakpoint.reset(); 702 } 703 m_breakpoint_list.Remove(break_id, true); 704 } 705 return true; 706 } 707 return false; 708} 709 710bool 711Target::DisableBreakpointByID (break_id_t break_id) 712{ 713 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 714 if (log) 715 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 716 717 BreakpointSP bp_sp; 718 719 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 720 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 721 else 722 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 723 if (bp_sp) 724 { 725 bp_sp->SetEnabled (false); 726 return true; 727 } 728 return false; 729} 730 731bool 732Target::EnableBreakpointByID (break_id_t break_id) 733{ 734 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 735 if (log) 736 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", 737 __FUNCTION__, 738 break_id, 739 LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 740 741 BreakpointSP bp_sp; 742 743 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 744 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 745 else 746 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 747 748 if (bp_sp) 749 { 750 bp_sp->SetEnabled (true); 751 return true; 752 } 753 return false; 754} 755 756// The flag 'end_to_end', default to true, signifies that the operation is 757// performed end to end, for both the debugger and the debuggee. 758 759// Assumption: Caller holds the list mutex lock for m_watchpoint_list for end 760// to end operations. 761bool 762Target::RemoveAllWatchpoints (bool end_to_end) 763{ 764 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 765 if (log) 766 log->Printf ("Target::%s\n", __FUNCTION__); 767 768 if (!end_to_end) { 769 m_watchpoint_list.RemoveAll(true); 770 return true; 771 } 772 773 // Otherwise, it's an end to end operation. 774 775 if (!ProcessIsValid()) 776 return false; 777 778 size_t num_watchpoints = m_watchpoint_list.GetSize(); 779 for (size_t i = 0; i < num_watchpoints; ++i) 780 { 781 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 782 if (!wp_sp) 783 return false; 784 785 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 786 if (rc.Fail()) 787 return false; 788 } 789 m_watchpoint_list.RemoveAll (true); 790 m_last_created_watchpoint.reset(); 791 return true; // Success! 792} 793 794// Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to 795// end operations. 796bool 797Target::DisableAllWatchpoints (bool end_to_end) 798{ 799 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 800 if (log) 801 log->Printf ("Target::%s\n", __FUNCTION__); 802 803 if (!end_to_end) { 804 m_watchpoint_list.SetEnabledAll(false); 805 return true; 806 } 807 808 // Otherwise, it's an end to end operation. 809 810 if (!ProcessIsValid()) 811 return false; 812 813 size_t num_watchpoints = m_watchpoint_list.GetSize(); 814 for (size_t i = 0; i < num_watchpoints; ++i) 815 { 816 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 817 if (!wp_sp) 818 return false; 819 820 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 821 if (rc.Fail()) 822 return false; 823 } 824 return true; // Success! 825} 826 827// Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to 828// end operations. 829bool 830Target::EnableAllWatchpoints (bool end_to_end) 831{ 832 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 833 if (log) 834 log->Printf ("Target::%s\n", __FUNCTION__); 835 836 if (!end_to_end) { 837 m_watchpoint_list.SetEnabledAll(true); 838 return true; 839 } 840 841 // Otherwise, it's an end to end operation. 842 843 if (!ProcessIsValid()) 844 return false; 845 846 size_t num_watchpoints = m_watchpoint_list.GetSize(); 847 for (size_t i = 0; i < num_watchpoints; ++i) 848 { 849 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 850 if (!wp_sp) 851 return false; 852 853 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get()); 854 if (rc.Fail()) 855 return false; 856 } 857 return true; // Success! 858} 859 860// Assumption: Caller holds the list mutex lock for m_watchpoint_list. 861bool 862Target::ClearAllWatchpointHitCounts () 863{ 864 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 865 if (log) 866 log->Printf ("Target::%s\n", __FUNCTION__); 867 868 size_t num_watchpoints = m_watchpoint_list.GetSize(); 869 for (size_t i = 0; i < num_watchpoints; ++i) 870 { 871 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 872 if (!wp_sp) 873 return false; 874 875 wp_sp->ResetHitCount(); 876 } 877 return true; // Success! 878} 879 880// Assumption: Caller holds the list mutex lock for m_watchpoint_list 881// during these operations. 882bool 883Target::IgnoreAllWatchpoints (uint32_t ignore_count) 884{ 885 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 886 if (log) 887 log->Printf ("Target::%s\n", __FUNCTION__); 888 889 if (!ProcessIsValid()) 890 return false; 891 892 size_t num_watchpoints = m_watchpoint_list.GetSize(); 893 for (size_t i = 0; i < num_watchpoints; ++i) 894 { 895 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 896 if (!wp_sp) 897 return false; 898 899 wp_sp->SetIgnoreCount(ignore_count); 900 } 901 return true; // Success! 902} 903 904// Assumption: Caller holds the list mutex lock for m_watchpoint_list. 905bool 906Target::DisableWatchpointByID (lldb::watch_id_t watch_id) 907{ 908 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 909 if (log) 910 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 911 912 if (!ProcessIsValid()) 913 return false; 914 915 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 916 if (wp_sp) 917 { 918 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 919 if (rc.Success()) 920 return true; 921 922 // Else, fallthrough. 923 } 924 return false; 925} 926 927// Assumption: Caller holds the list mutex lock for m_watchpoint_list. 928bool 929Target::EnableWatchpointByID (lldb::watch_id_t watch_id) 930{ 931 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 932 if (log) 933 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 934 935 if (!ProcessIsValid()) 936 return false; 937 938 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 939 if (wp_sp) 940 { 941 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get()); 942 if (rc.Success()) 943 return true; 944 945 // Else, fallthrough. 946 } 947 return false; 948} 949 950// Assumption: Caller holds the list mutex lock for m_watchpoint_list. 951bool 952Target::RemoveWatchpointByID (lldb::watch_id_t watch_id) 953{ 954 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 955 if (log) 956 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 957 958 WatchpointSP watch_to_remove_sp = m_watchpoint_list.FindByID(watch_id); 959 if (watch_to_remove_sp == m_last_created_watchpoint) 960 m_last_created_watchpoint.reset(); 961 962 if (DisableWatchpointByID (watch_id)) 963 { 964 m_watchpoint_list.Remove(watch_id, true); 965 return true; 966 } 967 return false; 968} 969 970// Assumption: Caller holds the list mutex lock for m_watchpoint_list. 971bool 972Target::IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count) 973{ 974 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 975 if (log) 976 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 977 978 if (!ProcessIsValid()) 979 return false; 980 981 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 982 if (wp_sp) 983 { 984 wp_sp->SetIgnoreCount(ignore_count); 985 return true; 986 } 987 return false; 988} 989 990ModuleSP 991Target::GetExecutableModule () 992{ 993 return m_images.GetModuleAtIndex(0); 994} 995 996Module* 997Target::GetExecutableModulePointer () 998{ 999 return m_images.GetModulePointerAtIndex(0); 1000} 1001 1002static void 1003LoadScriptingResourceForModule (const ModuleSP &module_sp, Target *target) 1004{ 1005 Error error; 1006 StreamString feedback_stream; 1007 if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error, &feedback_stream)) 1008 { 1009 if (error.AsCString()) 1010 target->GetDebugger().GetErrorFile()->Printf("unable to load scripting data for module %s - error reported was %s\n", 1011 module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(), 1012 error.AsCString()); 1013 if (feedback_stream.GetSize()) 1014 target->GetDebugger().GetErrorFile()->Printf("%s\n", 1015 feedback_stream.GetData()); 1016 } 1017} 1018 1019void 1020Target::ClearModules(bool delete_locations) 1021{ 1022 ModulesDidUnload (m_images, delete_locations); 1023 m_section_load_history.Clear(); 1024 m_images.Clear(); 1025 m_scratch_ast_context_ap.reset(); 1026 m_scratch_ast_source_ap.reset(); 1027 m_ast_importer_ap.reset(); 1028} 1029 1030void 1031Target::DidExec () 1032{ 1033 // When a process exec's we need to know about it so we can do some cleanup. 1034 m_breakpoint_list.RemoveInvalidLocations(m_arch); 1035 m_internal_breakpoint_list.RemoveInvalidLocations(m_arch); 1036} 1037 1038void 1039Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files) 1040{ 1041 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 1042 ClearModules(false); 1043 1044 if (executable_sp.get()) 1045 { 1046 Timer scoped_timer (__PRETTY_FUNCTION__, 1047 "Target::SetExecutableModule (executable = '%s')", 1048 executable_sp->GetFileSpec().GetPath().c_str()); 1049 1050 m_images.Append(executable_sp); // The first image is our exectuable file 1051 1052 // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module. 1053 if (!m_arch.IsValid()) 1054 { 1055 m_arch = executable_sp->GetArchitecture(); 1056 if (log) 1057 log->Printf ("Target::SetExecutableModule setting architecture to %s (%s) based on executable file", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 1058 } 1059 1060 FileSpecList dependent_files; 1061 ObjectFile *executable_objfile = executable_sp->GetObjectFile(); 1062 1063 if (executable_objfile && get_dependent_files) 1064 { 1065 executable_objfile->GetDependentModules(dependent_files); 1066 for (uint32_t i=0; i<dependent_files.GetSize(); i++) 1067 { 1068 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i)); 1069 FileSpec platform_dependent_file_spec; 1070 if (m_platform_sp) 1071 m_platform_sp->GetFileWithUUID (dependent_file_spec, NULL, platform_dependent_file_spec); 1072 else 1073 platform_dependent_file_spec = dependent_file_spec; 1074 1075 ModuleSpec module_spec (platform_dependent_file_spec, m_arch); 1076 ModuleSP image_module_sp(GetSharedModule (module_spec)); 1077 if (image_module_sp.get()) 1078 { 1079 ObjectFile *objfile = image_module_sp->GetObjectFile(); 1080 if (objfile) 1081 objfile->GetDependentModules(dependent_files); 1082 } 1083 } 1084 } 1085 } 1086} 1087 1088 1089bool 1090Target::SetArchitecture (const ArchSpec &arch_spec) 1091{ 1092 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 1093 if (m_arch.IsCompatibleMatch(arch_spec) || !m_arch.IsValid()) 1094 { 1095 // If we haven't got a valid arch spec, or the architectures are 1096 // compatible, so just update the architecture. Architectures can be 1097 // equal, yet the triple OS and vendor might change, so we need to do 1098 // the assignment here just in case. 1099 m_arch = arch_spec; 1100 if (log) 1101 log->Printf ("Target::SetArchitecture setting architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1102 return true; 1103 } 1104 else 1105 { 1106 // If we have an executable file, try to reset the executable to the desired architecture 1107 if (log) 1108 log->Printf ("Target::SetArchitecture changing architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1109 m_arch = arch_spec; 1110 ModuleSP executable_sp = GetExecutableModule (); 1111 1112 ClearModules(true); 1113 // Need to do something about unsetting breakpoints. 1114 1115 if (executable_sp) 1116 { 1117 if (log) 1118 log->Printf("Target::SetArchitecture Trying to select executable file architecture %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1119 ModuleSpec module_spec (executable_sp->GetFileSpec(), arch_spec); 1120 Error error = ModuleList::GetSharedModule (module_spec, 1121 executable_sp, 1122 &GetExecutableSearchPaths(), 1123 NULL, 1124 NULL); 1125 1126 if (!error.Fail() && executable_sp) 1127 { 1128 SetExecutableModule (executable_sp, true); 1129 return true; 1130 } 1131 } 1132 } 1133 return false; 1134} 1135 1136void 1137Target::WillClearList (const ModuleList& module_list) 1138{ 1139} 1140 1141void 1142Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp) 1143{ 1144 // A module is being added to this target for the first time 1145 ModuleList my_module_list; 1146 my_module_list.Append(module_sp); 1147 LoadScriptingResourceForModule(module_sp, this); 1148 ModulesDidLoad (my_module_list); 1149} 1150 1151void 1152Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp) 1153{ 1154 // A module is being added to this target for the first time 1155 ModuleList my_module_list; 1156 my_module_list.Append(module_sp); 1157 ModulesDidUnload (my_module_list, false); 1158} 1159 1160void 1161Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp) 1162{ 1163 // A module is replacing an already added module 1164 m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp); 1165} 1166 1167void 1168Target::ModulesDidLoad (ModuleList &module_list) 1169{ 1170 if (module_list.GetSize()) 1171 { 1172 m_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1173 if (m_process_sp) 1174 { 1175 SystemRuntime *sys_runtime = m_process_sp->GetSystemRuntime(); 1176 if (sys_runtime) 1177 { 1178 sys_runtime->ModulesDidLoad (module_list); 1179 } 1180 } 1181 // TODO: make event data that packages up the module_list 1182 BroadcastEvent (eBroadcastBitModulesLoaded, NULL); 1183 } 1184} 1185 1186void 1187Target::SymbolsDidLoad (ModuleList &module_list) 1188{ 1189 if (module_list.GetSize()) 1190 { 1191 if (m_process_sp) 1192 { 1193 LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); 1194 if (runtime) 1195 { 1196 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime; 1197 objc_runtime->SymbolsDidLoad(module_list); 1198 } 1199 } 1200 1201 m_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1202 BroadcastEvent(eBroadcastBitSymbolsLoaded, NULL); 1203 } 1204} 1205 1206void 1207Target::ModulesDidUnload (ModuleList &module_list, bool delete_locations) 1208{ 1209 if (module_list.GetSize()) 1210 { 1211 m_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations); 1212 // TODO: make event data that packages up the module_list 1213 BroadcastEvent (eBroadcastBitModulesUnloaded, NULL); 1214 } 1215} 1216 1217bool 1218Target::ModuleIsExcludedForNonModuleSpecificSearches (const FileSpec &module_file_spec) 1219{ 1220 if (GetBreakpointsConsultPlatformAvoidList()) 1221 { 1222 ModuleList matchingModules; 1223 ModuleSpec module_spec (module_file_spec); 1224 size_t num_modules = GetImages().FindModules(module_spec, matchingModules); 1225 1226 // If there is more than one module for this file spec, only return true if ALL the modules are on the 1227 // black list. 1228 if (num_modules > 0) 1229 { 1230 for (size_t i = 0; i < num_modules; i++) 1231 { 1232 if (!ModuleIsExcludedForNonModuleSpecificSearches (matchingModules.GetModuleAtIndex(i))) 1233 return false; 1234 } 1235 return true; 1236 } 1237 } 1238 return false; 1239} 1240 1241bool 1242Target::ModuleIsExcludedForNonModuleSpecificSearches (const lldb::ModuleSP &module_sp) 1243{ 1244 if (GetBreakpointsConsultPlatformAvoidList()) 1245 { 1246 if (m_platform_sp) 1247 return m_platform_sp->ModuleIsExcludedForNonModuleSpecificSearches (*this, module_sp); 1248 } 1249 return false; 1250} 1251 1252size_t 1253Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error) 1254{ 1255 SectionSP section_sp (addr.GetSection()); 1256 if (section_sp) 1257 { 1258 // If the contents of this section are encrypted, the on-disk file is unusuable. Read only from live memory. 1259 if (section_sp->IsEncrypted()) 1260 { 1261 error.SetErrorString("section is encrypted"); 1262 return 0; 1263 } 1264 ModuleSP module_sp (section_sp->GetModule()); 1265 if (module_sp) 1266 { 1267 ObjectFile *objfile = section_sp->GetModule()->GetObjectFile(); 1268 if (objfile) 1269 { 1270 size_t bytes_read = objfile->ReadSectionData (section_sp.get(), 1271 addr.GetOffset(), 1272 dst, 1273 dst_len); 1274 if (bytes_read > 0) 1275 return bytes_read; 1276 else 1277 error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString()); 1278 } 1279 else 1280 error.SetErrorString("address isn't from a object file"); 1281 } 1282 else 1283 error.SetErrorString("address isn't in a module"); 1284 } 1285 else 1286 error.SetErrorString("address doesn't contain a section that points to a section in a object file"); 1287 1288 return 0; 1289} 1290 1291size_t 1292Target::ReadMemory (const Address& addr, 1293 bool prefer_file_cache, 1294 void *dst, 1295 size_t dst_len, 1296 Error &error, 1297 lldb::addr_t *load_addr_ptr) 1298{ 1299 error.Clear(); 1300 1301 // if we end up reading this from process memory, we will fill this 1302 // with the actual load address 1303 if (load_addr_ptr) 1304 *load_addr_ptr = LLDB_INVALID_ADDRESS; 1305 1306 size_t bytes_read = 0; 1307 1308 addr_t load_addr = LLDB_INVALID_ADDRESS; 1309 addr_t file_addr = LLDB_INVALID_ADDRESS; 1310 Address resolved_addr; 1311 if (!addr.IsSectionOffset()) 1312 { 1313 SectionLoadList §ion_load_list = GetSectionLoadList(); 1314 if (section_load_list.IsEmpty()) 1315 { 1316 // No sections are loaded, so we must assume we are not running 1317 // yet and anything we are given is a file address. 1318 file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address 1319 m_images.ResolveFileAddress (file_addr, resolved_addr); 1320 } 1321 else 1322 { 1323 // We have at least one section loaded. This can be becuase 1324 // we have manually loaded some sections with "target modules load ..." 1325 // or because we have have a live process that has sections loaded 1326 // through the dynamic loader 1327 load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address 1328 section_load_list.ResolveLoadAddress (load_addr, resolved_addr); 1329 } 1330 } 1331 if (!resolved_addr.IsValid()) 1332 resolved_addr = addr; 1333 1334 1335 if (prefer_file_cache) 1336 { 1337 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1338 if (bytes_read > 0) 1339 return bytes_read; 1340 } 1341 1342 if (ProcessIsValid()) 1343 { 1344 if (load_addr == LLDB_INVALID_ADDRESS) 1345 load_addr = resolved_addr.GetLoadAddress (this); 1346 1347 if (load_addr == LLDB_INVALID_ADDRESS) 1348 { 1349 ModuleSP addr_module_sp (resolved_addr.GetModule()); 1350 if (addr_module_sp && addr_module_sp->GetFileSpec()) 1351 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded", 1352 addr_module_sp->GetFileSpec().GetFilename().AsCString(), 1353 resolved_addr.GetFileAddress(), 1354 addr_module_sp->GetFileSpec().GetFilename().AsCString()); 1355 else 1356 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress()); 1357 } 1358 else 1359 { 1360 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error); 1361 if (bytes_read != dst_len) 1362 { 1363 if (error.Success()) 1364 { 1365 if (bytes_read == 0) 1366 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr); 1367 else 1368 error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr); 1369 } 1370 } 1371 if (bytes_read) 1372 { 1373 if (load_addr_ptr) 1374 *load_addr_ptr = load_addr; 1375 return bytes_read; 1376 } 1377 // If the address is not section offset we have an address that 1378 // doesn't resolve to any address in any currently loaded shared 1379 // libaries and we failed to read memory so there isn't anything 1380 // more we can do. If it is section offset, we might be able to 1381 // read cached memory from the object file. 1382 if (!resolved_addr.IsSectionOffset()) 1383 return 0; 1384 } 1385 } 1386 1387 if (!prefer_file_cache && resolved_addr.IsSectionOffset()) 1388 { 1389 // If we didn't already try and read from the object file cache, then 1390 // try it after failing to read from the process. 1391 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1392 } 1393 return 0; 1394} 1395 1396size_t 1397Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error) 1398{ 1399 char buf[256]; 1400 out_str.clear(); 1401 addr_t curr_addr = addr.GetLoadAddress(this); 1402 Address address(addr); 1403 while (1) 1404 { 1405 size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error); 1406 if (length == 0) 1407 break; 1408 out_str.append(buf, length); 1409 // If we got "length - 1" bytes, we didn't get the whole C string, we 1410 // need to read some more characters 1411 if (length == sizeof(buf) - 1) 1412 curr_addr += length; 1413 else 1414 break; 1415 address = Address(curr_addr); 1416 } 1417 return out_str.size(); 1418} 1419 1420 1421size_t 1422Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error) 1423{ 1424 size_t total_cstr_len = 0; 1425 if (dst && dst_max_len) 1426 { 1427 result_error.Clear(); 1428 // NULL out everything just to be safe 1429 memset (dst, 0, dst_max_len); 1430 Error error; 1431 addr_t curr_addr = addr.GetLoadAddress(this); 1432 Address address(addr); 1433 const size_t cache_line_size = 512; 1434 size_t bytes_left = dst_max_len - 1; 1435 char *curr_dst = dst; 1436 1437 while (bytes_left > 0) 1438 { 1439 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size); 1440 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left); 1441 size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error); 1442 1443 if (bytes_read == 0) 1444 { 1445 result_error = error; 1446 dst[total_cstr_len] = '\0'; 1447 break; 1448 } 1449 const size_t len = strlen(curr_dst); 1450 1451 total_cstr_len += len; 1452 1453 if (len < bytes_to_read) 1454 break; 1455 1456 curr_dst += bytes_read; 1457 curr_addr += bytes_read; 1458 bytes_left -= bytes_read; 1459 address = Address(curr_addr); 1460 } 1461 } 1462 else 1463 { 1464 if (dst == NULL) 1465 result_error.SetErrorString("invalid arguments"); 1466 else 1467 result_error.Clear(); 1468 } 1469 return total_cstr_len; 1470} 1471 1472size_t 1473Target::ReadScalarIntegerFromMemory (const Address& addr, 1474 bool prefer_file_cache, 1475 uint32_t byte_size, 1476 bool is_signed, 1477 Scalar &scalar, 1478 Error &error) 1479{ 1480 uint64_t uval; 1481 1482 if (byte_size <= sizeof(uval)) 1483 { 1484 size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error); 1485 if (bytes_read == byte_size) 1486 { 1487 DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize()); 1488 lldb::offset_t offset = 0; 1489 if (byte_size <= 4) 1490 scalar = data.GetMaxU32 (&offset, byte_size); 1491 else 1492 scalar = data.GetMaxU64 (&offset, byte_size); 1493 1494 if (is_signed) 1495 scalar.SignExtend(byte_size * 8); 1496 return bytes_read; 1497 } 1498 } 1499 else 1500 { 1501 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size); 1502 } 1503 return 0; 1504} 1505 1506uint64_t 1507Target::ReadUnsignedIntegerFromMemory (const Address& addr, 1508 bool prefer_file_cache, 1509 size_t integer_byte_size, 1510 uint64_t fail_value, 1511 Error &error) 1512{ 1513 Scalar scalar; 1514 if (ReadScalarIntegerFromMemory (addr, 1515 prefer_file_cache, 1516 integer_byte_size, 1517 false, 1518 scalar, 1519 error)) 1520 return scalar.ULongLong(fail_value); 1521 return fail_value; 1522} 1523 1524bool 1525Target::ReadPointerFromMemory (const Address& addr, 1526 bool prefer_file_cache, 1527 Error &error, 1528 Address &pointer_addr) 1529{ 1530 Scalar scalar; 1531 if (ReadScalarIntegerFromMemory (addr, 1532 prefer_file_cache, 1533 m_arch.GetAddressByteSize(), 1534 false, 1535 scalar, 1536 error)) 1537 { 1538 addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS); 1539 if (pointer_vm_addr != LLDB_INVALID_ADDRESS) 1540 { 1541 SectionLoadList §ion_load_list = GetSectionLoadList(); 1542 if (section_load_list.IsEmpty()) 1543 { 1544 // No sections are loaded, so we must assume we are not running 1545 // yet and anything we are given is a file address. 1546 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr); 1547 } 1548 else 1549 { 1550 // We have at least one section loaded. This can be becuase 1551 // we have manually loaded some sections with "target modules load ..." 1552 // or because we have have a live process that has sections loaded 1553 // through the dynamic loader 1554 section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr); 1555 } 1556 // We weren't able to resolve the pointer value, so just return 1557 // an address with no section 1558 if (!pointer_addr.IsValid()) 1559 pointer_addr.SetOffset (pointer_vm_addr); 1560 return true; 1561 1562 } 1563 } 1564 return false; 1565} 1566 1567ModuleSP 1568Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr) 1569{ 1570 ModuleSP module_sp; 1571 1572 Error error; 1573 1574 // First see if we already have this module in our module list. If we do, then we're done, we don't need 1575 // to consult the shared modules list. But only do this if we are passed a UUID. 1576 1577 if (module_spec.GetUUID().IsValid()) 1578 module_sp = m_images.FindFirstModule(module_spec); 1579 1580 if (!module_sp) 1581 { 1582 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library 1583 bool did_create_module = false; 1584 1585 // If there are image search path entries, try to use them first to acquire a suitable image. 1586 if (m_image_search_paths.GetSize()) 1587 { 1588 ModuleSpec transformed_spec (module_spec); 1589 if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory())) 1590 { 1591 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename(); 1592 error = ModuleList::GetSharedModule (transformed_spec, 1593 module_sp, 1594 &GetExecutableSearchPaths(), 1595 &old_module_sp, 1596 &did_create_module); 1597 } 1598 } 1599 1600 if (!module_sp) 1601 { 1602 // If we have a UUID, we can check our global shared module list in case 1603 // we already have it. If we don't have a valid UUID, then we can't since 1604 // the path in "module_spec" will be a platform path, and we will need to 1605 // let the platform find that file. For example, we could be asking for 1606 // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick 1607 // the local copy of "/usr/lib/dyld" since our platform could be a remote 1608 // platform that has its own "/usr/lib/dyld" in an SDK or in a local file 1609 // cache. 1610 if (module_spec.GetUUID().IsValid()) 1611 { 1612 // We have a UUID, it is OK to check the global module list... 1613 error = ModuleList::GetSharedModule (module_spec, 1614 module_sp, 1615 &GetExecutableSearchPaths(), 1616 &old_module_sp, 1617 &did_create_module); 1618 } 1619 1620 if (!module_sp) 1621 { 1622 // The platform is responsible for finding and caching an appropriate 1623 // module in the shared module cache. 1624 if (m_platform_sp) 1625 { 1626 FileSpec platform_file_spec; 1627 error = m_platform_sp->GetSharedModule (module_spec, 1628 module_sp, 1629 &GetExecutableSearchPaths(), 1630 &old_module_sp, 1631 &did_create_module); 1632 } 1633 else 1634 { 1635 error.SetErrorString("no platform is currently set"); 1636 } 1637 } 1638 } 1639 1640 // We found a module that wasn't in our target list. Let's make sure that there wasn't an equivalent 1641 // module in the list already, and if there was, let's remove it. 1642 if (module_sp) 1643 { 1644 ObjectFile *objfile = module_sp->GetObjectFile(); 1645 if (objfile) 1646 { 1647 switch (objfile->GetType()) 1648 { 1649 case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of a program's execution state 1650 case ObjectFile::eTypeExecutable: /// A normal executable 1651 case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable 1652 case ObjectFile::eTypeObjectFile: /// An intermediate object file 1653 case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution 1654 break; 1655 case ObjectFile::eTypeDebugInfo: /// An object file that contains only debug information 1656 if (error_ptr) 1657 error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable"); 1658 return ModuleSP(); 1659 case ObjectFile::eTypeStubLibrary: /// A library that can be linked against but not used for execution 1660 if (error_ptr) 1661 error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable"); 1662 return ModuleSP(); 1663 default: 1664 if (error_ptr) 1665 error_ptr->SetErrorString("unsupported file type, please specify an executable"); 1666 return ModuleSP(); 1667 } 1668 // GetSharedModule is not guaranteed to find the old shared module, for instance 1669 // in the common case where you pass in the UUID, it is only going to find the one 1670 // module matching the UUID. In fact, it has no good way to know what the "old module" 1671 // relevant to this target is, since there might be many copies of a module with this file spec 1672 // in various running debug sessions, but only one of them will belong to this target. 1673 // So let's remove the UUID from the module list, and look in the target's module list. 1674 // Only do this if there is SOMETHING else in the module spec... 1675 if (!old_module_sp) 1676 { 1677 if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty()) 1678 { 1679 ModuleSpec module_spec_copy(module_spec.GetFileSpec()); 1680 module_spec_copy.GetUUID().Clear(); 1681 1682 ModuleList found_modules; 1683 size_t num_found = m_images.FindModules (module_spec_copy, found_modules); 1684 if (num_found == 1) 1685 { 1686 old_module_sp = found_modules.GetModuleAtIndex(0); 1687 } 1688 } 1689 } 1690 1691 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32) 1692 { 1693 m_images.ReplaceModule(old_module_sp, module_sp); 1694 Module *old_module_ptr = old_module_sp.get(); 1695 old_module_sp.reset(); 1696 ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr); 1697 } 1698 else 1699 m_images.Append(module_sp); 1700 } 1701 } 1702 } 1703 if (error_ptr) 1704 *error_ptr = error; 1705 return module_sp; 1706} 1707 1708 1709TargetSP 1710Target::CalculateTarget () 1711{ 1712 return shared_from_this(); 1713} 1714 1715ProcessSP 1716Target::CalculateProcess () 1717{ 1718 return ProcessSP(); 1719} 1720 1721ThreadSP 1722Target::CalculateThread () 1723{ 1724 return ThreadSP(); 1725} 1726 1727StackFrameSP 1728Target::CalculateStackFrame () 1729{ 1730 return StackFrameSP(); 1731} 1732 1733void 1734Target::CalculateExecutionContext (ExecutionContext &exe_ctx) 1735{ 1736 exe_ctx.Clear(); 1737 exe_ctx.SetTargetPtr(this); 1738} 1739 1740PathMappingList & 1741Target::GetImageSearchPathList () 1742{ 1743 return m_image_search_paths; 1744} 1745 1746void 1747Target::ImageSearchPathsChanged 1748( 1749 const PathMappingList &path_list, 1750 void *baton 1751) 1752{ 1753 Target *target = (Target *)baton; 1754 ModuleSP exe_module_sp (target->GetExecutableModule()); 1755 if (exe_module_sp) 1756 target->SetExecutableModule (exe_module_sp, true); 1757} 1758 1759ClangASTContext * 1760Target::GetScratchClangASTContext(bool create_on_demand) 1761{ 1762 // Now see if we know the target triple, and if so, create our scratch AST context: 1763 if (m_scratch_ast_context_ap.get() == NULL && m_arch.IsValid() && create_on_demand) 1764 { 1765 m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch.GetTriple().str().c_str())); 1766 m_scratch_ast_source_ap.reset (new ClangASTSource(shared_from_this())); 1767 m_scratch_ast_source_ap->InstallASTContext(m_scratch_ast_context_ap->getASTContext()); 1768 llvm::OwningPtr<clang::ExternalASTSource> proxy_ast_source(m_scratch_ast_source_ap->CreateProxy()); 1769 m_scratch_ast_context_ap->SetExternalSource(proxy_ast_source); 1770 } 1771 return m_scratch_ast_context_ap.get(); 1772} 1773 1774ClangASTImporter * 1775Target::GetClangASTImporter() 1776{ 1777 ClangASTImporter *ast_importer = m_ast_importer_ap.get(); 1778 1779 if (!ast_importer) 1780 { 1781 ast_importer = new ClangASTImporter(); 1782 m_ast_importer_ap.reset(ast_importer); 1783 } 1784 1785 return ast_importer; 1786} 1787 1788void 1789Target::SettingsInitialize () 1790{ 1791 Process::SettingsInitialize (); 1792} 1793 1794void 1795Target::SettingsTerminate () 1796{ 1797 Process::SettingsTerminate (); 1798} 1799 1800FileSpecList 1801Target::GetDefaultExecutableSearchPaths () 1802{ 1803 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1804 if (properties_sp) 1805 return properties_sp->GetExecutableSearchPaths(); 1806 return FileSpecList(); 1807} 1808 1809FileSpecList 1810Target::GetDefaultDebugFileSearchPaths () 1811{ 1812 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1813 if (properties_sp) 1814 return properties_sp->GetDebugFileSearchPaths(); 1815 return FileSpecList(); 1816} 1817 1818ArchSpec 1819Target::GetDefaultArchitecture () 1820{ 1821 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1822 if (properties_sp) 1823 return properties_sp->GetDefaultArchitecture(); 1824 return ArchSpec(); 1825} 1826 1827void 1828Target::SetDefaultArchitecture (const ArchSpec &arch) 1829{ 1830 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1831 if (properties_sp) 1832 { 1833 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str()); 1834 return properties_sp->SetDefaultArchitecture(arch); 1835 } 1836} 1837 1838Target * 1839Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) 1840{ 1841 // The target can either exist in the "process" of ExecutionContext, or in 1842 // the "target_sp" member of SymbolContext. This accessor helper function 1843 // will get the target from one of these locations. 1844 1845 Target *target = NULL; 1846 if (sc_ptr != NULL) 1847 target = sc_ptr->target_sp.get(); 1848 if (target == NULL && exe_ctx_ptr) 1849 target = exe_ctx_ptr->GetTargetPtr(); 1850 return target; 1851} 1852 1853ExecutionResults 1854Target::EvaluateExpression 1855( 1856 const char *expr_cstr, 1857 StackFrame *frame, 1858 lldb::ValueObjectSP &result_valobj_sp, 1859 const EvaluateExpressionOptions& options 1860) 1861{ 1862 result_valobj_sp.reset(); 1863 1864 ExecutionResults execution_results = eExecutionSetupError; 1865 1866 if (expr_cstr == NULL || expr_cstr[0] == '\0') 1867 return execution_results; 1868 1869 // We shouldn't run stop hooks in expressions. 1870 // Be sure to reset this if you return anywhere within this function. 1871 bool old_suppress_value = m_suppress_stop_hooks; 1872 m_suppress_stop_hooks = true; 1873 1874 ExecutionContext exe_ctx; 1875 1876 if (frame) 1877 { 1878 frame->CalculateExecutionContext(exe_ctx); 1879 } 1880 else if (m_process_sp) 1881 { 1882 m_process_sp->CalculateExecutionContext(exe_ctx); 1883 } 1884 else 1885 { 1886 CalculateExecutionContext(exe_ctx); 1887 } 1888 1889 // Make sure we aren't just trying to see the value of a persistent 1890 // variable (something like "$0") 1891 lldb::ClangExpressionVariableSP persistent_var_sp; 1892 // Only check for persistent variables the expression starts with a '$' 1893 if (expr_cstr[0] == '$') 1894 persistent_var_sp = m_persistent_variables.GetVariable (expr_cstr); 1895 1896 if (persistent_var_sp) 1897 { 1898 result_valobj_sp = persistent_var_sp->GetValueObject (); 1899 execution_results = eExecutionCompleted; 1900 } 1901 else 1902 { 1903 const char *prefix = GetExpressionPrefixContentsAsCString(); 1904 Error error; 1905 execution_results = ClangUserExpression::Evaluate (exe_ctx, 1906 options, 1907 expr_cstr, 1908 prefix, 1909 result_valobj_sp, 1910 error); 1911 } 1912 1913 m_suppress_stop_hooks = old_suppress_value; 1914 1915 return execution_results; 1916} 1917 1918lldb::addr_t 1919Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 1920{ 1921 addr_t code_addr = load_addr; 1922 switch (m_arch.GetMachine()) 1923 { 1924 case llvm::Triple::arm: 1925 case llvm::Triple::thumb: 1926 switch (addr_class) 1927 { 1928 case eAddressClassData: 1929 case eAddressClassDebug: 1930 return LLDB_INVALID_ADDRESS; 1931 1932 case eAddressClassUnknown: 1933 case eAddressClassInvalid: 1934 case eAddressClassCode: 1935 case eAddressClassCodeAlternateISA: 1936 case eAddressClassRuntime: 1937 // Check if bit zero it no set? 1938 if ((code_addr & 1ull) == 0) 1939 { 1940 // Bit zero isn't set, check if the address is a multiple of 2? 1941 if (code_addr & 2ull) 1942 { 1943 // The address is a multiple of 2 so it must be thumb, set bit zero 1944 code_addr |= 1ull; 1945 } 1946 else if (addr_class == eAddressClassCodeAlternateISA) 1947 { 1948 // We checked the address and the address claims to be the alternate ISA 1949 // which means thumb, so set bit zero. 1950 code_addr |= 1ull; 1951 } 1952 } 1953 break; 1954 } 1955 break; 1956 1957 default: 1958 break; 1959 } 1960 return code_addr; 1961} 1962 1963lldb::addr_t 1964Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 1965{ 1966 addr_t opcode_addr = load_addr; 1967 switch (m_arch.GetMachine()) 1968 { 1969 case llvm::Triple::arm: 1970 case llvm::Triple::thumb: 1971 switch (addr_class) 1972 { 1973 case eAddressClassData: 1974 case eAddressClassDebug: 1975 return LLDB_INVALID_ADDRESS; 1976 1977 case eAddressClassInvalid: 1978 case eAddressClassUnknown: 1979 case eAddressClassCode: 1980 case eAddressClassCodeAlternateISA: 1981 case eAddressClassRuntime: 1982 opcode_addr &= ~(1ull); 1983 break; 1984 } 1985 break; 1986 1987 default: 1988 break; 1989 } 1990 return opcode_addr; 1991} 1992 1993SourceManager & 1994Target::GetSourceManager () 1995{ 1996 if (m_source_manager_ap.get() == NULL) 1997 m_source_manager_ap.reset (new SourceManager(shared_from_this())); 1998 return *m_source_manager_ap; 1999} 2000 2001 2002Target::StopHookSP 2003Target::CreateStopHook () 2004{ 2005 lldb::user_id_t new_uid = ++m_stop_hook_next_id; 2006 Target::StopHookSP stop_hook_sp (new StopHook(shared_from_this(), new_uid)); 2007 m_stop_hooks[new_uid] = stop_hook_sp; 2008 return stop_hook_sp; 2009} 2010 2011bool 2012Target::RemoveStopHookByID (lldb::user_id_t user_id) 2013{ 2014 size_t num_removed; 2015 num_removed = m_stop_hooks.erase (user_id); 2016 if (num_removed == 0) 2017 return false; 2018 else 2019 return true; 2020} 2021 2022void 2023Target::RemoveAllStopHooks () 2024{ 2025 m_stop_hooks.clear(); 2026} 2027 2028Target::StopHookSP 2029Target::GetStopHookByID (lldb::user_id_t user_id) 2030{ 2031 StopHookSP found_hook; 2032 2033 StopHookCollection::iterator specified_hook_iter; 2034 specified_hook_iter = m_stop_hooks.find (user_id); 2035 if (specified_hook_iter != m_stop_hooks.end()) 2036 found_hook = (*specified_hook_iter).second; 2037 return found_hook; 2038} 2039 2040bool 2041Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state) 2042{ 2043 StopHookCollection::iterator specified_hook_iter; 2044 specified_hook_iter = m_stop_hooks.find (user_id); 2045 if (specified_hook_iter == m_stop_hooks.end()) 2046 return false; 2047 2048 (*specified_hook_iter).second->SetIsActive (active_state); 2049 return true; 2050} 2051 2052void 2053Target::SetAllStopHooksActiveState (bool active_state) 2054{ 2055 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 2056 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2057 { 2058 (*pos).second->SetIsActive (active_state); 2059 } 2060} 2061 2062void 2063Target::RunStopHooks () 2064{ 2065 if (m_suppress_stop_hooks) 2066 return; 2067 2068 if (!m_process_sp) 2069 return; 2070 2071 // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression 2072 // since in that case we do not want to run the stop-hooks 2073 if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression()) 2074 return; 2075 2076 if (m_stop_hooks.empty()) 2077 return; 2078 2079 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 2080 2081 // If there aren't any active stop hooks, don't bother either: 2082 bool any_active_hooks = false; 2083 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2084 { 2085 if ((*pos).second->IsActive()) 2086 { 2087 any_active_hooks = true; 2088 break; 2089 } 2090 } 2091 if (!any_active_hooks) 2092 return; 2093 2094 CommandReturnObject result; 2095 2096 std::vector<ExecutionContext> exc_ctx_with_reasons; 2097 std::vector<SymbolContext> sym_ctx_with_reasons; 2098 2099 ThreadList &cur_threadlist = m_process_sp->GetThreadList(); 2100 size_t num_threads = cur_threadlist.GetSize(); 2101 for (size_t i = 0; i < num_threads; i++) 2102 { 2103 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i); 2104 if (cur_thread_sp->ThreadStoppedForAReason()) 2105 { 2106 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0); 2107 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get())); 2108 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything)); 2109 } 2110 } 2111 2112 // If no threads stopped for a reason, don't run the stop-hooks. 2113 size_t num_exe_ctx = exc_ctx_with_reasons.size(); 2114 if (num_exe_ctx == 0) 2115 return; 2116 2117 result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream()); 2118 result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream()); 2119 2120 bool keep_going = true; 2121 bool hooks_ran = false; 2122 bool print_hook_header; 2123 bool print_thread_header; 2124 2125 if (num_exe_ctx == 1) 2126 print_thread_header = false; 2127 else 2128 print_thread_header = true; 2129 2130 if (m_stop_hooks.size() == 1) 2131 print_hook_header = false; 2132 else 2133 print_hook_header = true; 2134 2135 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) 2136 { 2137 // result.Clear(); 2138 StopHookSP cur_hook_sp = (*pos).second; 2139 if (!cur_hook_sp->IsActive()) 2140 continue; 2141 2142 bool any_thread_matched = false; 2143 for (size_t i = 0; keep_going && i < num_exe_ctx; i++) 2144 { 2145 if ((cur_hook_sp->GetSpecifier () == NULL 2146 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i])) 2147 && (cur_hook_sp->GetThreadSpecifier() == NULL 2148 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef()))) 2149 { 2150 if (!hooks_ran) 2151 { 2152 hooks_ran = true; 2153 } 2154 if (print_hook_header && !any_thread_matched) 2155 { 2156 const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ? 2157 cur_hook_sp->GetCommands().GetStringAtIndex(0) : 2158 NULL); 2159 if (cmd) 2160 result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd); 2161 else 2162 result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID()); 2163 any_thread_matched = true; 2164 } 2165 2166 if (print_thread_header) 2167 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID()); 2168 2169 bool stop_on_continue = true; 2170 bool stop_on_error = true; 2171 bool echo_commands = false; 2172 bool print_results = true; 2173 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(), 2174 &exc_ctx_with_reasons[i], 2175 stop_on_continue, 2176 stop_on_error, 2177 echo_commands, 2178 print_results, 2179 eLazyBoolNo, 2180 result); 2181 2182 // If the command started the target going again, we should bag out of 2183 // running the stop hooks. 2184 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) || 2185 (result.GetStatus() == eReturnStatusSuccessContinuingResult)) 2186 { 2187 result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID()); 2188 keep_going = false; 2189 } 2190 } 2191 } 2192 } 2193 2194 result.GetImmediateOutputStream()->Flush(); 2195 result.GetImmediateErrorStream()->Flush(); 2196} 2197 2198const TargetPropertiesSP & 2199Target::GetGlobalProperties() 2200{ 2201 static TargetPropertiesSP g_settings_sp; 2202 if (!g_settings_sp) 2203 { 2204 g_settings_sp.reset (new TargetProperties (NULL)); 2205 } 2206 return g_settings_sp; 2207} 2208 2209Error 2210Target::Install (ProcessLaunchInfo *launch_info) 2211{ 2212 Error error; 2213 PlatformSP platform_sp (GetPlatform()); 2214 if (platform_sp) 2215 { 2216 if (platform_sp->IsRemote()) 2217 { 2218 if (platform_sp->IsConnected()) 2219 { 2220 // Install all files that have an install path, and always install the 2221 // main executable when connected to a remote platform 2222 const ModuleList& modules = GetImages(); 2223 const size_t num_images = modules.GetSize(); 2224 for (size_t idx = 0; idx < num_images; ++idx) 2225 { 2226 const bool is_main_executable = idx == 0; 2227 ModuleSP module_sp(modules.GetModuleAtIndex(idx)); 2228 if (module_sp) 2229 { 2230 FileSpec local_file (module_sp->GetFileSpec()); 2231 if (local_file) 2232 { 2233 FileSpec remote_file (module_sp->GetRemoteInstallFileSpec()); 2234 if (!remote_file) 2235 { 2236 if (is_main_executable) // TODO: add setting for always installing main executable??? 2237 { 2238 // Always install the main executable 2239 remote_file.GetDirectory() = platform_sp->GetWorkingDirectory(); 2240 remote_file.GetFilename() = module_sp->GetFileSpec().GetFilename(); 2241 } 2242 } 2243 if (remote_file) 2244 { 2245 error = platform_sp->Install(local_file, remote_file); 2246 if (error.Success()) 2247 { 2248 module_sp->SetPlatformFileSpec(remote_file); 2249 if (is_main_executable) 2250 { 2251 if (launch_info) 2252 launch_info->SetExecutableFile(remote_file, false); 2253 } 2254 } 2255 else 2256 break; 2257 } 2258 } 2259 } 2260 } 2261 } 2262 } 2263 } 2264 return error; 2265} 2266 2267bool 2268Target::ResolveLoadAddress (addr_t load_addr, Address &so_addr, uint32_t stop_id) 2269{ 2270 return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr); 2271} 2272 2273bool 2274Target::SetSectionLoadAddress (const SectionSP §ion_sp, addr_t new_section_load_addr, bool warn_multiple) 2275{ 2276 const addr_t old_section_load_addr = m_section_load_history.GetSectionLoadAddress (SectionLoadHistory::eStopIDNow, section_sp); 2277 if (old_section_load_addr != new_section_load_addr) 2278 { 2279 uint32_t stop_id = 0; 2280 ProcessSP process_sp(GetProcessSP()); 2281 if (process_sp) 2282 stop_id = process_sp->GetStopID(); 2283 else 2284 stop_id = m_section_load_history.GetLastStopID(); 2285 if (m_section_load_history.SetSectionLoadAddress (stop_id, section_sp, new_section_load_addr, warn_multiple)) 2286 return true; // Return true if the section load address was changed... 2287 } 2288 return false; // Return false to indicate nothing changed 2289 2290} 2291 2292bool 2293Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp) 2294{ 2295 uint32_t stop_id = 0; 2296 ProcessSP process_sp(GetProcessSP()); 2297 if (process_sp) 2298 stop_id = process_sp->GetStopID(); 2299 else 2300 stop_id = m_section_load_history.GetLastStopID(); 2301 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp); 2302} 2303 2304bool 2305Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp, addr_t load_addr) 2306{ 2307 uint32_t stop_id = 0; 2308 ProcessSP process_sp(GetProcessSP()); 2309 if (process_sp) 2310 stop_id = process_sp->GetStopID(); 2311 else 2312 stop_id = m_section_load_history.GetLastStopID(); 2313 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp, load_addr); 2314} 2315 2316void 2317Target::ClearAllLoadedSections () 2318{ 2319 m_section_load_history.Clear(); 2320} 2321 2322 2323Error 2324Target::Launch (Listener &listener, ProcessLaunchInfo &launch_info) 2325{ 2326 Error error; 2327 2328 StateType state = eStateInvalid; 2329 2330 // Scope to temporarily get the process state in case someone has manually 2331 // remotely connected already to a process and we can skip the platform 2332 // launching. 2333 { 2334 ProcessSP process_sp (GetProcessSP()); 2335 2336 if (process_sp) 2337 state = process_sp->GetState(); 2338 } 2339 2340 launch_info.GetFlags().Set (eLaunchFlagDebug); 2341 2342 // Get the value of synchronous execution here. If you wait till after you have started to 2343 // run, then you could have hit a breakpoint, whose command might switch the value, and 2344 // then you'll pick up that incorrect value. 2345 Debugger &debugger = GetDebugger(); 2346 const bool synchronous_execution = debugger.GetCommandInterpreter().GetSynchronous (); 2347 2348 PlatformSP platform_sp (GetPlatform()); 2349 2350 // Finalize the file actions, and if none were given, default to opening 2351 // up a pseudo terminal 2352 const bool default_to_use_pty = platform_sp ? platform_sp->IsHost() : false; 2353 launch_info.FinalizeFileActions (this, default_to_use_pty); 2354 2355 if (state == eStateConnected) 2356 { 2357 if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY)) 2358 { 2359 error.SetErrorString("can't launch in tty when launching through a remote connection"); 2360 return error; 2361 } 2362 } 2363 2364 if (!launch_info.GetArchitecture().IsValid()) 2365 launch_info.GetArchitecture() = GetArchitecture(); 2366 2367 if (state != eStateConnected && platform_sp && platform_sp->CanDebugProcess ()) 2368 { 2369 m_process_sp = GetPlatform()->DebugProcess (launch_info, 2370 debugger, 2371 this, 2372 listener, 2373 error); 2374 } 2375 else 2376 { 2377 if (state == eStateConnected) 2378 { 2379 assert(m_process_sp); 2380 } 2381 else 2382 { 2383 const char *plugin_name = launch_info.GetProcessPluginName(); 2384 CreateProcess (listener, plugin_name, NULL); 2385 } 2386 2387 if (m_process_sp) 2388 error = m_process_sp->Launch (launch_info); 2389 } 2390 2391 if (!m_process_sp) 2392 { 2393 if (error.Success()) 2394 error.SetErrorString("failed to launch or debug process"); 2395 return error; 2396 } 2397 2398 if (error.Success()) 2399 { 2400 if (launch_info.GetFlags().Test(eLaunchFlagStopAtEntry) == false) 2401 { 2402 ListenerSP hijack_listener_sp (launch_info.GetHijackListener()); 2403 2404 StateType state = m_process_sp->WaitForProcessToStop (NULL, NULL, false, hijack_listener_sp.get()); 2405 2406 if (state == eStateStopped) 2407 { 2408 if (!synchronous_execution) 2409 m_process_sp->RestoreProcessEvents (); 2410 2411 error = m_process_sp->PrivateResume(); 2412 2413 if (error.Success()) 2414 { 2415 if (synchronous_execution) 2416 { 2417 state = m_process_sp->WaitForProcessToStop (NULL, NULL, true, hijack_listener_sp.get()); 2418 const bool must_be_alive = false; // eStateExited is ok, so this must be false 2419 if (!StateIsStoppedState(state, must_be_alive)) 2420 { 2421 error.SetErrorStringWithFormat("process isn't stopped: %s", StateAsCString(state)); 2422 } 2423 } 2424 } 2425 else 2426 { 2427 Error error2; 2428 error2.SetErrorStringWithFormat("process resume at entry point failed: %s", error.AsCString()); 2429 error = error2; 2430 } 2431 } 2432 else 2433 { 2434 error.SetErrorStringWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state)); 2435 } 2436 } 2437 m_process_sp->RestoreProcessEvents (); 2438 } 2439 else 2440 { 2441 Error error2; 2442 error2.SetErrorStringWithFormat ("process launch failed: %s", error.AsCString()); 2443 error = error2; 2444 } 2445 return error; 2446} 2447//-------------------------------------------------------------- 2448// Target::StopHook 2449//-------------------------------------------------------------- 2450Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : 2451 UserID (uid), 2452 m_target_sp (target_sp), 2453 m_commands (), 2454 m_specifier_sp (), 2455 m_thread_spec_ap(), 2456 m_active (true) 2457{ 2458} 2459 2460Target::StopHook::StopHook (const StopHook &rhs) : 2461 UserID (rhs.GetID()), 2462 m_target_sp (rhs.m_target_sp), 2463 m_commands (rhs.m_commands), 2464 m_specifier_sp (rhs.m_specifier_sp), 2465 m_thread_spec_ap (), 2466 m_active (rhs.m_active) 2467{ 2468 if (rhs.m_thread_spec_ap.get() != NULL) 2469 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); 2470} 2471 2472 2473Target::StopHook::~StopHook () 2474{ 2475} 2476 2477void 2478Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) 2479{ 2480 m_thread_spec_ap.reset (specifier); 2481} 2482 2483 2484void 2485Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const 2486{ 2487 int indent_level = s->GetIndentLevel(); 2488 2489 s->SetIndentLevel(indent_level + 2); 2490 2491 s->Printf ("Hook: %" PRIu64 "\n", GetID()); 2492 if (m_active) 2493 s->Indent ("State: enabled\n"); 2494 else 2495 s->Indent ("State: disabled\n"); 2496 2497 if (m_specifier_sp) 2498 { 2499 s->Indent(); 2500 s->PutCString ("Specifier:\n"); 2501 s->SetIndentLevel (indent_level + 4); 2502 m_specifier_sp->GetDescription (s, level); 2503 s->SetIndentLevel (indent_level + 2); 2504 } 2505 2506 if (m_thread_spec_ap.get() != NULL) 2507 { 2508 StreamString tmp; 2509 s->Indent("Thread:\n"); 2510 m_thread_spec_ap->GetDescription (&tmp, level); 2511 s->SetIndentLevel (indent_level + 4); 2512 s->Indent (tmp.GetData()); 2513 s->PutCString ("\n"); 2514 s->SetIndentLevel (indent_level + 2); 2515 } 2516 2517 s->Indent ("Commands: \n"); 2518 s->SetIndentLevel (indent_level + 4); 2519 uint32_t num_commands = m_commands.GetSize(); 2520 for (uint32_t i = 0; i < num_commands; i++) 2521 { 2522 s->Indent(m_commands.GetStringAtIndex(i)); 2523 s->PutCString ("\n"); 2524 } 2525 s->SetIndentLevel (indent_level); 2526} 2527 2528//-------------------------------------------------------------- 2529// class TargetProperties 2530//-------------------------------------------------------------- 2531 2532OptionEnumValueElement 2533lldb_private::g_dynamic_value_types[] = 2534{ 2535 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"}, 2536 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."}, 2537 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."}, 2538 { 0, NULL, NULL } 2539}; 2540 2541static OptionEnumValueElement 2542g_inline_breakpoint_enums[] = 2543{ 2544 { eInlineBreakpointsNever, "never", "Never look for inline breakpoint locations (fastest). This setting should only be used if you know that no inlining occurs in your programs."}, 2545 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."}, 2546 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."}, 2547 { 0, NULL, NULL } 2548}; 2549 2550typedef enum x86DisassemblyFlavor 2551{ 2552 eX86DisFlavorDefault, 2553 eX86DisFlavorIntel, 2554 eX86DisFlavorATT 2555} x86DisassemblyFlavor; 2556 2557static OptionEnumValueElement 2558g_x86_dis_flavor_value_types[] = 2559{ 2560 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."}, 2561 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."}, 2562 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."}, 2563 { 0, NULL, NULL } 2564}; 2565 2566static OptionEnumValueElement 2567g_hex_immediate_style_values[] = 2568{ 2569 { Disassembler::eHexStyleC, "c", "C-style (0xffff)."}, 2570 { Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."}, 2571 { 0, NULL, NULL } 2572}; 2573 2574static OptionEnumValueElement 2575g_load_script_from_sym_file_values[] = 2576{ 2577 { eLoadScriptFromSymFileTrue, "true", "Load debug scripts inside symbol files"}, 2578 { eLoadScriptFromSymFileFalse, "false", "Do not load debug scripts inside symbol files."}, 2579 { eLoadScriptFromSymFileWarn, "warn", "Warn about debug scripts inside symbol files but do not load them."}, 2580 { 0, NULL, NULL } 2581}; 2582 2583 2584static OptionEnumValueElement 2585g_memory_module_load_level_values[] = 2586{ 2587 { eMemoryModuleLoadLevelMinimal, "minimal" , "Load minimal information when loading modules from memory. Currently this setting loads sections only."}, 2588 { eMemoryModuleLoadLevelPartial, "partial" , "Load partial information when loading modules from memory. Currently this setting loads sections and function bounds."}, 2589 { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."}, 2590 { 0, NULL, NULL } 2591}; 2592 2593static PropertyDefinition 2594g_properties[] = 2595{ 2596 { "default-arch" , OptionValue::eTypeArch , true , 0 , NULL, NULL, "Default architecture to choose, when there's a choice." }, 2597 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "Path to a file containing expressions to be prepended to all expressions." }, 2598 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eNoDynamicValues , NULL, g_dynamic_value_types, "Should printed values be shown as their dynamic value." }, 2599 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Should synthetic values be used by default whenever available." }, 2600 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Skip function prologues when setting breakpoints by name." }, 2601 { "source-map" , OptionValue::eTypePathMap , false, 0 , NULL, NULL, "Source path remappings used to track the change of location between a source file when built, and " 2602 "where it exists on the current system. It consists of an array of duples, the first element of each duple is " 2603 "some part (starting at the root) of the path to the file when it was built, " 2604 "and the second is where the remainder of the original build hierarchy is rooted on the local system. " 2605 "Each element of the array is checked in order and the first one that results in a match wins." }, 2606 { "exec-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , NULL, NULL, "Executable search paths to use when locating executable files whose paths don't match the local file system." }, 2607 { "debug-file-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , NULL, NULL, "List of directories to be searched when locating debug symbol files." }, 2608 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , NULL, NULL, "Maximum number of children to expand in any level of depth." }, 2609 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of characters to show when using %s in summary strings." }, 2610 { "max-memory-read-size" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." }, 2611 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , NULL, NULL, "Consult the platform module avoid list when setting non-module specific breakpoints." }, 2612 { "arg0" , OptionValue::eTypeString , false, 0 , NULL, NULL, "The first argument passed to the program in the argument array which can be different from the executable itself." }, 2613 { "run-args" , OptionValue::eTypeArgs , false, 0 , NULL, NULL, "A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0." }, 2614 { "env-vars" , OptionValue::eTypeDictionary, false, OptionValue::eTypeString , NULL, NULL, "A list of all the environment variables to be passed to the executable's environment, and their values." }, 2615 { "inherit-env" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Inherit the environment from the process that is running LLDB." }, 2616 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for reading its standard input." }, 2617 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard output." }, 2618 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard error." }, 2619 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Disable Address Space Layout Randomization (ASLR)" }, 2620 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , NULL, NULL, "Disable stdin/stdout for process (e.g. for a GUI application)" }, 2621 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsHeaders , NULL, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. " 2622 "Breakpoint locations can end up being inlined by the compiler, so that a compile unit 'a.c' might contain an inlined function from another source file. " 2623 "Usually this is limitted to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. " 2624 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. " 2625 "Always checking for inlined breakpoint locations can be expensive (memory and time), so we try to minimize the " 2626 "times we look for inlined locations. This setting allows you to control exactly which strategy is used when settings " 2627 "file and line breakpoints." }, 2628 // FIXME: This is the wrong way to do per-architecture settings, but we don't have a general per architecture settings system in place yet. 2629 { "x86-disassembly-flavor" , OptionValue::eTypeEnum , false, eX86DisFlavorDefault, NULL, g_x86_dis_flavor_value_types, "The default disassembly flavor to use for x86 or x86-64 targets." }, 2630 { "use-hex-immediates" , OptionValue::eTypeBoolean , false, true, NULL, NULL, "Show immediates in disassembly as hexadecimal." }, 2631 { "hex-immediate-style" , OptionValue::eTypeEnum , false, Disassembler::eHexStyleC, NULL, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." }, 2632 { "use-fast-stepping" , OptionValue::eTypeBoolean , false, true, NULL, NULL, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping." }, 2633 { "load-script-from-symbol-file" , OptionValue::eTypeEnum , false, eLoadScriptFromSymFileWarn, NULL, g_load_script_from_sym_file_values, "Allow LLDB to load scripting resources embedded in symbol files when available." }, 2634 { "memory-module-load-level" , OptionValue::eTypeEnum , false, eMemoryModuleLoadLevelComplete, NULL, g_memory_module_load_level_values, 2635 "Loading modules from memory can be slow as reading the symbol tables and other data can take a long time depending on your connection to the debug target. " 2636 "This setting helps users control how much information gets loaded when loading modules from memory." 2637 "'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). " 2638 "'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). " 2639 "'minimal' is the fastest setting and will load section data with no symbols, but should rarely be used as stack frames in these memory regions will be inaccurate and not provide any context (fastest). " }, 2640 { "display-expression-in-crashlogs" , OptionValue::eTypeBoolean , false, false, NULL, NULL, "Expressions that crash will show up in crash logs if the host system supports executable specific crash log strings and this setting is set to true." }, 2641 { "trap-handler-names" , OptionValue::eTypeArray , true, OptionValue::eTypeString, NULL, NULL, "A list of trap handler function names, e.g. a common Unix user process one is _sigtramp." }, 2642 { NULL , OptionValue::eTypeInvalid , false, 0 , NULL, NULL, NULL } 2643}; 2644enum 2645{ 2646 ePropertyDefaultArch, 2647 ePropertyExprPrefix, 2648 ePropertyPreferDynamic, 2649 ePropertyEnableSynthetic, 2650 ePropertySkipPrologue, 2651 ePropertySourceMap, 2652 ePropertyExecutableSearchPaths, 2653 ePropertyDebugFileSearchPaths, 2654 ePropertyMaxChildrenCount, 2655 ePropertyMaxSummaryLength, 2656 ePropertyMaxMemReadSize, 2657 ePropertyBreakpointUseAvoidList, 2658 ePropertyArg0, 2659 ePropertyRunArgs, 2660 ePropertyEnvVars, 2661 ePropertyInheritEnv, 2662 ePropertyInputPath, 2663 ePropertyOutputPath, 2664 ePropertyErrorPath, 2665 ePropertyDisableASLR, 2666 ePropertyDisableSTDIO, 2667 ePropertyInlineStrategy, 2668 ePropertyDisassemblyFlavor, 2669 ePropertyUseHexImmediates, 2670 ePropertyHexImmediateStyle, 2671 ePropertyUseFastStepping, 2672 ePropertyLoadScriptFromSymbolFile, 2673 ePropertyMemoryModuleLoadLevel, 2674 ePropertyDisplayExpressionsInCrashlogs, 2675 ePropertyTrapHandlerNames 2676}; 2677 2678 2679class TargetOptionValueProperties : public OptionValueProperties 2680{ 2681public: 2682 TargetOptionValueProperties (const ConstString &name) : 2683 OptionValueProperties (name), 2684 m_target (NULL), 2685 m_got_host_env (false) 2686 { 2687 } 2688 2689 // This constructor is used when creating TargetOptionValueProperties when it 2690 // is part of a new lldb_private::Target instance. It will copy all current 2691 // global property values as needed 2692 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) : 2693 OptionValueProperties(*target_properties_sp->GetValueProperties()), 2694 m_target (target), 2695 m_got_host_env (false) 2696 { 2697 } 2698 2699 virtual const Property * 2700 GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const 2701 { 2702 // When gettings the value for a key from the target options, we will always 2703 // try and grab the setting from the current target if there is one. Else we just 2704 // use the one from this instance. 2705 if (idx == ePropertyEnvVars) 2706 GetHostEnvironmentIfNeeded (); 2707 2708 if (exe_ctx) 2709 { 2710 Target *target = exe_ctx->GetTargetPtr(); 2711 if (target) 2712 { 2713 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get()); 2714 if (this != target_properties) 2715 return target_properties->ProtectedGetPropertyAtIndex (idx); 2716 } 2717 } 2718 return ProtectedGetPropertyAtIndex (idx); 2719 } 2720 2721 lldb::TargetSP 2722 GetTargetSP () 2723 { 2724 return m_target->shared_from_this(); 2725 } 2726 2727protected: 2728 2729 void 2730 GetHostEnvironmentIfNeeded () const 2731 { 2732 if (!m_got_host_env) 2733 { 2734 if (m_target) 2735 { 2736 m_got_host_env = true; 2737 const uint32_t idx = ePropertyInheritEnv; 2738 if (GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0)) 2739 { 2740 PlatformSP platform_sp (m_target->GetPlatform()); 2741 if (platform_sp) 2742 { 2743 StringList env; 2744 if (platform_sp->GetEnvironment(env)) 2745 { 2746 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary (NULL, ePropertyEnvVars); 2747 if (env_dict) 2748 { 2749 const bool can_replace = false; 2750 const size_t envc = env.GetSize(); 2751 for (size_t idx=0; idx<envc; idx++) 2752 { 2753 const char *env_entry = env.GetStringAtIndex (idx); 2754 if (env_entry) 2755 { 2756 const char *equal_pos = ::strchr(env_entry, '='); 2757 ConstString key; 2758 // It is ok to have environment variables with no values 2759 const char *value = NULL; 2760 if (equal_pos) 2761 { 2762 key.SetCStringWithLength(env_entry, equal_pos - env_entry); 2763 if (equal_pos[1]) 2764 value = equal_pos + 1; 2765 } 2766 else 2767 { 2768 key.SetCString(env_entry); 2769 } 2770 // Don't allow existing keys to be replaced with ones we get from the platform environment 2771 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace); 2772 } 2773 } 2774 } 2775 } 2776 } 2777 } 2778 } 2779 } 2780 } 2781 Target *m_target; 2782 mutable bool m_got_host_env; 2783}; 2784 2785//---------------------------------------------------------------------- 2786// TargetProperties 2787//---------------------------------------------------------------------- 2788TargetProperties::TargetProperties (Target *target) : 2789 Properties () 2790{ 2791 if (target) 2792 { 2793 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties())); 2794 } 2795 else 2796 { 2797 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target"))); 2798 m_collection_sp->Initialize(g_properties); 2799 m_collection_sp->AppendProperty(ConstString("process"), 2800 ConstString("Settings specify to processes."), 2801 true, 2802 Process::GetGlobalProperties()->GetValueProperties()); 2803 } 2804} 2805 2806TargetProperties::~TargetProperties () 2807{ 2808} 2809ArchSpec 2810TargetProperties::GetDefaultArchitecture () const 2811{ 2812 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch); 2813 if (value) 2814 return value->GetCurrentValue(); 2815 return ArchSpec(); 2816} 2817 2818void 2819TargetProperties::SetDefaultArchitecture (const ArchSpec& arch) 2820{ 2821 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch); 2822 if (value) 2823 return value->SetCurrentValue(arch, true); 2824} 2825 2826lldb::DynamicValueType 2827TargetProperties::GetPreferDynamicValue() const 2828{ 2829 const uint32_t idx = ePropertyPreferDynamic; 2830 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 2831} 2832 2833bool 2834TargetProperties::GetDisableASLR () const 2835{ 2836 const uint32_t idx = ePropertyDisableASLR; 2837 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2838} 2839 2840void 2841TargetProperties::SetDisableASLR (bool b) 2842{ 2843 const uint32_t idx = ePropertyDisableASLR; 2844 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 2845} 2846 2847bool 2848TargetProperties::GetDisableSTDIO () const 2849{ 2850 const uint32_t idx = ePropertyDisableSTDIO; 2851 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2852} 2853 2854void 2855TargetProperties::SetDisableSTDIO (bool b) 2856{ 2857 const uint32_t idx = ePropertyDisableSTDIO; 2858 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 2859} 2860 2861const char * 2862TargetProperties::GetDisassemblyFlavor () const 2863{ 2864 const uint32_t idx = ePropertyDisassemblyFlavor; 2865 const char *return_value; 2866 2867 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 2868 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value; 2869 return return_value; 2870} 2871 2872InlineStrategy 2873TargetProperties::GetInlineStrategy () const 2874{ 2875 const uint32_t idx = ePropertyInlineStrategy; 2876 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 2877} 2878 2879const char * 2880TargetProperties::GetArg0 () const 2881{ 2882 const uint32_t idx = ePropertyArg0; 2883 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, NULL); 2884} 2885 2886void 2887TargetProperties::SetArg0 (const char *arg) 2888{ 2889 const uint32_t idx = ePropertyArg0; 2890 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, arg); 2891} 2892 2893bool 2894TargetProperties::GetRunArguments (Args &args) const 2895{ 2896 const uint32_t idx = ePropertyRunArgs; 2897 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, args); 2898} 2899 2900void 2901TargetProperties::SetRunArguments (const Args &args) 2902{ 2903 const uint32_t idx = ePropertyRunArgs; 2904 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, args); 2905} 2906 2907size_t 2908TargetProperties::GetEnvironmentAsArgs (Args &env) const 2909{ 2910 const uint32_t idx = ePropertyEnvVars; 2911 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, env); 2912} 2913 2914bool 2915TargetProperties::GetSkipPrologue() const 2916{ 2917 const uint32_t idx = ePropertySkipPrologue; 2918 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2919} 2920 2921PathMappingList & 2922TargetProperties::GetSourcePathMap () const 2923{ 2924 const uint32_t idx = ePropertySourceMap; 2925 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings (NULL, false, idx); 2926 assert(option_value); 2927 return option_value->GetCurrentValue(); 2928} 2929 2930FileSpecList & 2931TargetProperties::GetExecutableSearchPaths () 2932{ 2933 const uint32_t idx = ePropertyExecutableSearchPaths; 2934 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx); 2935 assert(option_value); 2936 return option_value->GetCurrentValue(); 2937} 2938 2939FileSpecList & 2940TargetProperties::GetDebugFileSearchPaths () 2941{ 2942 const uint32_t idx = ePropertyDebugFileSearchPaths; 2943 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx); 2944 assert(option_value); 2945 return option_value->GetCurrentValue(); 2946} 2947 2948bool 2949TargetProperties::GetEnableSyntheticValue () const 2950{ 2951 const uint32_t idx = ePropertyEnableSynthetic; 2952 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2953} 2954 2955uint32_t 2956TargetProperties::GetMaximumNumberOfChildrenToDisplay() const 2957{ 2958 const uint32_t idx = ePropertyMaxChildrenCount; 2959 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 2960} 2961 2962uint32_t 2963TargetProperties::GetMaximumSizeOfStringSummary() const 2964{ 2965 const uint32_t idx = ePropertyMaxSummaryLength; 2966 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 2967} 2968 2969uint32_t 2970TargetProperties::GetMaximumMemReadSize () const 2971{ 2972 const uint32_t idx = ePropertyMaxMemReadSize; 2973 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 2974} 2975 2976FileSpec 2977TargetProperties::GetStandardInputPath () const 2978{ 2979 const uint32_t idx = ePropertyInputPath; 2980 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 2981} 2982 2983void 2984TargetProperties::SetStandardInputPath (const char *p) 2985{ 2986 const uint32_t idx = ePropertyInputPath; 2987 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 2988} 2989 2990FileSpec 2991TargetProperties::GetStandardOutputPath () const 2992{ 2993 const uint32_t idx = ePropertyOutputPath; 2994 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 2995} 2996 2997void 2998TargetProperties::SetStandardOutputPath (const char *p) 2999{ 3000 const uint32_t idx = ePropertyOutputPath; 3001 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 3002} 3003 3004FileSpec 3005TargetProperties::GetStandardErrorPath () const 3006{ 3007 const uint32_t idx = ePropertyErrorPath; 3008 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx); 3009} 3010 3011const char * 3012TargetProperties::GetExpressionPrefixContentsAsCString () 3013{ 3014 const uint32_t idx = ePropertyExprPrefix; 3015 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec (NULL, false, idx); 3016 if (file) 3017 { 3018 const bool null_terminate = true; 3019 DataBufferSP data_sp(file->GetFileContents(null_terminate)); 3020 if (data_sp) 3021 return (const char *) data_sp->GetBytes(); 3022 } 3023 return NULL; 3024} 3025 3026void 3027TargetProperties::SetStandardErrorPath (const char *p) 3028{ 3029 const uint32_t idx = ePropertyErrorPath; 3030 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 3031} 3032 3033bool 3034TargetProperties::GetBreakpointsConsultPlatformAvoidList () 3035{ 3036 const uint32_t idx = ePropertyBreakpointUseAvoidList; 3037 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3038} 3039 3040bool 3041TargetProperties::GetUseHexImmediates () const 3042{ 3043 const uint32_t idx = ePropertyUseHexImmediates; 3044 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3045} 3046 3047bool 3048TargetProperties::GetUseFastStepping () const 3049{ 3050 const uint32_t idx = ePropertyUseFastStepping; 3051 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3052} 3053 3054bool 3055TargetProperties::GetDisplayExpressionsInCrashlogs () const 3056{ 3057 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs; 3058 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3059} 3060 3061LoadScriptFromSymFile 3062TargetProperties::GetLoadScriptFromSymbolFile () const 3063{ 3064 const uint32_t idx = ePropertyLoadScriptFromSymbolFile; 3065 return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value); 3066} 3067 3068Disassembler::HexImmediateStyle 3069TargetProperties::GetHexImmediateStyle () const 3070{ 3071 const uint32_t idx = ePropertyHexImmediateStyle; 3072 return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value); 3073} 3074 3075MemoryModuleLoadLevel 3076TargetProperties::GetMemoryModuleLoadLevel() const 3077{ 3078 const uint32_t idx = ePropertyMemoryModuleLoadLevel; 3079 return (MemoryModuleLoadLevel)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value); 3080} 3081 3082bool 3083TargetProperties::GetUserSpecifiedTrapHandlerNames (Args &args) const 3084{ 3085 const uint32_t idx = ePropertyTrapHandlerNames; 3086 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, args); 3087} 3088 3089void 3090TargetProperties::SetUserSpecifiedTrapHandlerNames (const Args &args) 3091{ 3092 const uint32_t idx = ePropertyTrapHandlerNames; 3093 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, args); 3094} 3095 3096//---------------------------------------------------------------------- 3097// Target::TargetEventData 3098//---------------------------------------------------------------------- 3099const ConstString & 3100Target::TargetEventData::GetFlavorString () 3101{ 3102 static ConstString g_flavor ("Target::TargetEventData"); 3103 return g_flavor; 3104} 3105 3106const ConstString & 3107Target::TargetEventData::GetFlavor () const 3108{ 3109 return TargetEventData::GetFlavorString (); 3110} 3111 3112Target::TargetEventData::TargetEventData (const lldb::TargetSP &new_target_sp) : 3113 EventData(), 3114 m_target_sp (new_target_sp) 3115{ 3116} 3117 3118Target::TargetEventData::~TargetEventData() 3119{ 3120 3121} 3122 3123void 3124Target::TargetEventData::Dump (Stream *s) const 3125{ 3126 3127} 3128 3129const TargetSP 3130Target::TargetEventData::GetTargetFromEvent (const lldb::EventSP &event_sp) 3131{ 3132 TargetSP target_sp; 3133 3134 const TargetEventData *data = GetEventDataFromEvent (event_sp.get()); 3135 if (data) 3136 target_sp = data->m_target_sp; 3137 3138 return target_sp; 3139} 3140 3141const Target::TargetEventData * 3142Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr) 3143{ 3144 if (event_ptr) 3145 { 3146 const EventData *event_data = event_ptr->GetData(); 3147 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString()) 3148 return static_cast <const TargetEventData *> (event_ptr->GetData()); 3149 } 3150 return NULL; 3151} 3152 3153