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