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