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