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