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 // C Includes 11 // C++ Includes 12 #include <mutex> 13 // Other libraries and framework includes 14 // Project includes 15 #include "lldb/Target/Target.h" 16 #include "lldb/Breakpoint/BreakpointResolver.h" 17 #include "lldb/Breakpoint/BreakpointResolverAddress.h" 18 #include "lldb/Breakpoint/BreakpointResolverFileLine.h" 19 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h" 20 #include "lldb/Breakpoint/BreakpointResolverName.h" 21 #include "lldb/Breakpoint/Watchpoint.h" 22 #include "lldb/Core/Debugger.h" 23 #include "lldb/Core/Event.h" 24 #include "lldb/Core/Log.h" 25 #include "lldb/Core/Module.h" 26 #include "lldb/Core/ModuleSpec.h" 27 #include "lldb/Core/Section.h" 28 #include "lldb/Core/SourceManager.h" 29 #include "lldb/Core/State.h" 30 #include "lldb/Core/StreamFile.h" 31 #include "lldb/Core/StreamString.h" 32 #include "lldb/Core/Timer.h" 33 #include "lldb/Core/ValueObject.h" 34 #include "lldb/Expression/REPL.h" 35 #include "lldb/Expression/UserExpression.h" 36 #include "Plugins/ExpressionParser/Clang/ClangASTSource.h" 37 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" 38 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" 39 #include "lldb/Host/FileSpec.h" 40 #include "lldb/Host/Host.h" 41 #include "lldb/Interpreter/CommandInterpreter.h" 42 #include "lldb/Interpreter/CommandReturnObject.h" 43 #include "lldb/Interpreter/OptionGroupWatchpoint.h" 44 #include "lldb/Interpreter/OptionValues.h" 45 #include "lldb/Interpreter/Property.h" 46 #include "lldb/Symbol/ClangASTContext.h" 47 #include "lldb/Symbol/ObjectFile.h" 48 #include "lldb/Symbol/Function.h" 49 #include "lldb/Symbol/Symbol.h" 50 #include "lldb/Target/Language.h" 51 #include "lldb/Target/LanguageRuntime.h" 52 #include "lldb/Target/ObjCLanguageRuntime.h" 53 #include "lldb/Target/Process.h" 54 #include "lldb/Target/SectionLoadList.h" 55 #include "lldb/Target/StackFrame.h" 56 #include "lldb/Target/SystemRuntime.h" 57 #include "lldb/Target/Thread.h" 58 #include "lldb/Target/ThreadSpec.h" 59 #include "lldb/Utility/LLDBAssert.h" 60 61 using namespace lldb; 62 using namespace lldb_private; 63 64 ConstString & 65 Target::GetStaticBroadcasterClass () 66 { 67 static ConstString class_name ("lldb.target"); 68 return class_name; 69 } 70 71 Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, 72 bool is_dummy_target) 73 : TargetProperties(this), 74 Broadcaster(debugger.GetBroadcasterManager(), Target::GetStaticBroadcasterClass().AsCString()), 75 ExecutionContextScope(), 76 m_debugger(debugger), 77 m_platform_sp(platform_sp), 78 m_mutex(), 79 m_arch(target_arch), 80 m_images(this), 81 m_section_load_history(), 82 m_breakpoint_list(false), 83 m_internal_breakpoint_list(true), 84 m_watchpoint_list(), 85 m_process_sp(), 86 m_search_filter_sp(), 87 m_image_search_paths(ImageSearchPathsChanged, this), 88 m_ast_importer_sp(), 89 m_source_manager_ap(), 90 m_stop_hooks(), 91 m_stop_hook_next_id(0), 92 m_valid(true), 93 m_suppress_stop_hooks(false), 94 m_is_dummy_target(is_dummy_target) 95 96 { 97 SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed"); 98 SetEventName(eBroadcastBitModulesLoaded, "modules-loaded"); 99 SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded"); 100 SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed"); 101 SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded"); 102 103 CheckInWithManager(); 104 105 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); 106 if (log) 107 log->Printf("%p Target::Target()", static_cast<void *>(this)); 108 if (m_arch.IsValid()) 109 { 110 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", 111 m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 112 } 113 } 114 115 Target::~Target() 116 { 117 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 118 if (log) 119 log->Printf ("%p Target::~Target()", static_cast<void*>(this)); 120 DeleteCurrentProcess (); 121 } 122 123 void 124 Target::PrimeFromDummyTarget(Target *target) 125 { 126 if (!target) 127 return; 128 129 m_stop_hooks = target->m_stop_hooks; 130 131 for (BreakpointSP breakpoint_sp : target->m_breakpoint_list.Breakpoints()) 132 { 133 if (breakpoint_sp->IsInternal()) 134 continue; 135 136 BreakpointSP new_bp (new Breakpoint (*this, *breakpoint_sp.get())); 137 AddBreakpoint (new_bp, false); 138 } 139 } 140 141 void 142 Target::Dump (Stream *s, lldb::DescriptionLevel description_level) 143 { 144 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 145 if (description_level != lldb::eDescriptionLevelBrief) 146 { 147 s->Indent(); 148 s->PutCString("Target\n"); 149 s->IndentMore(); 150 m_images.Dump(s); 151 m_breakpoint_list.Dump(s); 152 m_internal_breakpoint_list.Dump(s); 153 s->IndentLess(); 154 } 155 else 156 { 157 Module *exe_module = GetExecutableModulePointer(); 158 if (exe_module) 159 s->PutCString (exe_module->GetFileSpec().GetFilename().GetCString()); 160 else 161 s->PutCString ("No executable module."); 162 } 163 } 164 165 void 166 Target::CleanupProcess () 167 { 168 // Do any cleanup of the target we need to do between process instances. 169 // NB It is better to do this before destroying the process in case the 170 // clean up needs some help from the process. 171 m_breakpoint_list.ClearAllBreakpointSites(); 172 m_internal_breakpoint_list.ClearAllBreakpointSites(); 173 // Disable watchpoints just on the debugger side. 174 std::unique_lock<std::recursive_mutex> lock; 175 this->GetWatchpointList().GetListMutex(lock); 176 DisableAllWatchpoints(false); 177 ClearAllWatchpointHitCounts(); 178 ClearAllWatchpointHistoricValues(); 179 } 180 181 void 182 Target::DeleteCurrentProcess () 183 { 184 if (m_process_sp) 185 { 186 m_section_load_history.Clear(); 187 if (m_process_sp->IsAlive()) 188 m_process_sp->Destroy(false); 189 190 m_process_sp->Finalize(); 191 192 CleanupProcess (); 193 194 m_process_sp.reset(); 195 } 196 } 197 198 const lldb::ProcessSP & 199 Target::CreateProcess (ListenerSP listener_sp, const char *plugin_name, const FileSpec *crash_file) 200 { 201 DeleteCurrentProcess (); 202 m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name, listener_sp, crash_file); 203 return m_process_sp; 204 } 205 206 const lldb::ProcessSP & 207 Target::GetProcessSP () const 208 { 209 return m_process_sp; 210 } 211 212 lldb::REPLSP 213 Target::GetREPL (Error &err, lldb::LanguageType language, const char *repl_options, bool can_create) 214 { 215 if (language == eLanguageTypeUnknown) 216 { 217 std::set<LanguageType> repl_languages; 218 219 Language::GetLanguagesSupportingREPLs(repl_languages); 220 221 if (repl_languages.size() == 1) 222 { 223 language = *repl_languages.begin(); 224 } 225 else if (repl_languages.size() == 0) 226 { 227 err.SetErrorStringWithFormat("LLDB isn't configured with REPL support for any languages."); 228 return REPLSP(); 229 } 230 else 231 { 232 err.SetErrorStringWithFormat("Multiple possible REPL languages. Please specify a language."); 233 return REPLSP(); 234 } 235 } 236 237 REPLMap::iterator pos = m_repl_map.find(language); 238 239 if (pos != m_repl_map.end()) 240 { 241 return pos->second; 242 } 243 244 if (!can_create) 245 { 246 err.SetErrorStringWithFormat("Couldn't find an existing REPL for %s, and can't create a new one", Language::GetNameForLanguageType(language)); 247 return lldb::REPLSP(); 248 } 249 250 Debugger *const debugger = nullptr; 251 lldb::REPLSP ret = REPL::Create(err, language, debugger, this, repl_options); 252 253 if (ret) 254 { 255 m_repl_map[language] = ret; 256 return m_repl_map[language]; 257 } 258 259 if (err.Success()) 260 { 261 err.SetErrorStringWithFormat("Couldn't create a REPL for %s", Language::GetNameForLanguageType(language)); 262 } 263 264 return lldb::REPLSP(); 265 } 266 267 void 268 Target::SetREPL (lldb::LanguageType language, lldb::REPLSP repl_sp) 269 { 270 lldbassert(!m_repl_map.count(language)); 271 272 m_repl_map[language] = repl_sp; 273 } 274 275 void 276 Target::Destroy() 277 { 278 std::lock_guard<std::recursive_mutex> guard(m_mutex); 279 m_valid = false; 280 DeleteCurrentProcess (); 281 m_platform_sp.reset(); 282 m_arch.Clear(); 283 ClearModules(true); 284 m_section_load_history.Clear(); 285 const bool notify = false; 286 m_breakpoint_list.RemoveAll(notify); 287 m_internal_breakpoint_list.RemoveAll(notify); 288 m_last_created_breakpoint.reset(); 289 m_last_created_watchpoint.reset(); 290 m_search_filter_sp.reset(); 291 m_image_search_paths.Clear(notify); 292 m_stop_hooks.clear(); 293 m_stop_hook_next_id = 0; 294 m_suppress_stop_hooks = false; 295 } 296 297 BreakpointList & 298 Target::GetBreakpointList(bool internal) 299 { 300 if (internal) 301 return m_internal_breakpoint_list; 302 else 303 return m_breakpoint_list; 304 } 305 306 const BreakpointList & 307 Target::GetBreakpointList(bool internal) const 308 { 309 if (internal) 310 return m_internal_breakpoint_list; 311 else 312 return m_breakpoint_list; 313 } 314 315 BreakpointSP 316 Target::GetBreakpointByID (break_id_t break_id) 317 { 318 BreakpointSP bp_sp; 319 320 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 321 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 322 else 323 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 324 325 return bp_sp; 326 } 327 328 BreakpointSP 329 Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules, 330 const FileSpecList *source_file_spec_list, 331 const std::unordered_set<std::string> &function_names, 332 RegularExpression &source_regex, 333 bool internal, 334 bool hardware, 335 LazyBool move_to_nearest_code) 336 { 337 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list)); 338 if (move_to_nearest_code == eLazyBoolCalculate) 339 move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo; 340 BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex(nullptr, 341 source_regex, 342 function_names, 343 !static_cast<bool>(move_to_nearest_code))); 344 345 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 346 } 347 348 BreakpointSP 349 Target::CreateBreakpoint (const FileSpecList *containingModules, 350 const FileSpec &file, 351 uint32_t line_no, 352 lldb::addr_t offset, 353 LazyBool check_inlines, 354 LazyBool skip_prologue, 355 bool internal, 356 bool hardware, 357 LazyBool move_to_nearest_code) 358 { 359 FileSpec remapped_file; 360 ConstString remapped_path; 361 if (GetSourcePathMap().ReverseRemapPath(ConstString(file.GetPath().c_str()), remapped_path)) 362 remapped_file.SetFile(remapped_path.AsCString(), true); 363 else 364 remapped_file = file; 365 366 if (check_inlines == eLazyBoolCalculate) 367 { 368 const InlineStrategy inline_strategy = GetInlineStrategy(); 369 switch (inline_strategy) 370 { 371 case eInlineBreakpointsNever: 372 check_inlines = eLazyBoolNo; 373 break; 374 375 case eInlineBreakpointsHeaders: 376 if (remapped_file.IsSourceImplementationFile()) 377 check_inlines = eLazyBoolNo; 378 else 379 check_inlines = eLazyBoolYes; 380 break; 381 382 case eInlineBreakpointsAlways: 383 check_inlines = eLazyBoolYes; 384 break; 385 } 386 } 387 SearchFilterSP filter_sp; 388 if (check_inlines == eLazyBoolNo) 389 { 390 // Not checking for inlines, we are looking only for matching compile units 391 FileSpecList compile_unit_list; 392 compile_unit_list.Append (remapped_file); 393 filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list); 394 } 395 else 396 { 397 filter_sp = GetSearchFilterForModuleList (containingModules); 398 } 399 if (skip_prologue == eLazyBoolCalculate) 400 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 401 if (move_to_nearest_code == eLazyBoolCalculate) 402 move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo; 403 404 BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (nullptr, 405 remapped_file, 406 line_no, 407 offset, 408 check_inlines, 409 skip_prologue, 410 !static_cast<bool>(move_to_nearest_code))); 411 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 412 } 413 414 BreakpointSP 415 Target::CreateBreakpoint (lldb::addr_t addr, bool internal, bool hardware) 416 { 417 Address so_addr; 418 419 // Check for any reason we want to move this breakpoint to other address. 420 addr = GetBreakableLoadAddress(addr); 421 422 // Attempt to resolve our load address if possible, though it is ok if 423 // it doesn't resolve to section/offset. 424 425 // Try and resolve as a load address if possible 426 GetSectionLoadList().ResolveLoadAddress(addr, so_addr); 427 if (!so_addr.IsValid()) 428 { 429 // The address didn't resolve, so just set this as an absolute address 430 so_addr.SetOffset (addr); 431 } 432 BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal, hardware)); 433 return bp_sp; 434 } 435 436 BreakpointSP 437 Target::CreateBreakpoint (const Address &addr, bool internal, bool hardware) 438 { 439 SearchFilterSP filter_sp(new SearchFilterForUnconstrainedSearches (shared_from_this())); 440 BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(nullptr, addr)); 441 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, false); 442 } 443 444 lldb::BreakpointSP 445 Target::CreateAddressInModuleBreakpoint (lldb::addr_t file_addr, 446 bool internal, 447 const FileSpec *file_spec, 448 bool request_hardware) 449 { 450 SearchFilterSP filter_sp(new SearchFilterForUnconstrainedSearches (shared_from_this())); 451 BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(nullptr, file_addr, file_spec)); 452 return CreateBreakpoint (filter_sp, resolver_sp, internal, request_hardware, false); 453 } 454 455 BreakpointSP 456 Target::CreateBreakpoint (const FileSpecList *containingModules, 457 const FileSpecList *containingSourceFiles, 458 const char *func_name, 459 uint32_t func_name_type_mask, 460 LanguageType language, 461 lldb::addr_t offset, 462 LazyBool skip_prologue, 463 bool internal, 464 bool hardware) 465 { 466 BreakpointSP bp_sp; 467 if (func_name) 468 { 469 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 470 471 if (skip_prologue == eLazyBoolCalculate) 472 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 473 if (language == lldb::eLanguageTypeUnknown) 474 language = GetLanguage(); 475 476 BreakpointResolverSP resolver_sp (new BreakpointResolverName (nullptr, 477 func_name, 478 func_name_type_mask, 479 language, 480 Breakpoint::Exact, 481 offset, 482 skip_prologue)); 483 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 484 } 485 return bp_sp; 486 } 487 488 lldb::BreakpointSP 489 Target::CreateBreakpoint (const FileSpecList *containingModules, 490 const FileSpecList *containingSourceFiles, 491 const std::vector<std::string> &func_names, 492 uint32_t func_name_type_mask, 493 LanguageType language, 494 lldb::addr_t offset, 495 LazyBool skip_prologue, 496 bool internal, 497 bool hardware) 498 { 499 BreakpointSP bp_sp; 500 size_t num_names = func_names.size(); 501 if (num_names > 0) 502 { 503 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 504 505 if (skip_prologue == eLazyBoolCalculate) 506 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 507 if (language == lldb::eLanguageTypeUnknown) 508 language = GetLanguage(); 509 510 511 BreakpointResolverSP resolver_sp (new BreakpointResolverName (nullptr, 512 func_names, 513 func_name_type_mask, 514 language, 515 offset, 516 skip_prologue)); 517 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 518 } 519 return bp_sp; 520 } 521 522 BreakpointSP 523 Target::CreateBreakpoint (const FileSpecList *containingModules, 524 const FileSpecList *containingSourceFiles, 525 const char *func_names[], 526 size_t num_names, 527 uint32_t func_name_type_mask, 528 LanguageType language, 529 lldb::addr_t offset, 530 LazyBool skip_prologue, 531 bool internal, 532 bool hardware) 533 { 534 BreakpointSP bp_sp; 535 if (num_names > 0) 536 { 537 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 538 539 if (skip_prologue == eLazyBoolCalculate) 540 { 541 if (offset == 0) 542 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo; 543 else 544 skip_prologue = eLazyBoolNo; 545 } 546 if (language == lldb::eLanguageTypeUnknown) 547 language = GetLanguage(); 548 549 BreakpointResolverSP resolver_sp (new BreakpointResolverName (nullptr, 550 func_names, 551 num_names, 552 func_name_type_mask, 553 language, 554 offset, 555 skip_prologue)); 556 resolver_sp->SetOffset(offset); 557 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 558 } 559 return bp_sp; 560 } 561 562 SearchFilterSP 563 Target::GetSearchFilterForModule (const FileSpec *containingModule) 564 { 565 SearchFilterSP filter_sp; 566 if (containingModule != nullptr) 567 { 568 // TODO: We should look into sharing module based search filters 569 // across many breakpoints like we do for the simple target based one 570 filter_sp.reset (new SearchFilterByModule (shared_from_this(), *containingModule)); 571 } 572 else 573 { 574 if (!m_search_filter_sp) 575 m_search_filter_sp.reset (new SearchFilterForUnconstrainedSearches (shared_from_this())); 576 filter_sp = m_search_filter_sp; 577 } 578 return filter_sp; 579 } 580 581 SearchFilterSP 582 Target::GetSearchFilterForModuleList (const FileSpecList *containingModules) 583 { 584 SearchFilterSP filter_sp; 585 if (containingModules && containingModules->GetSize() != 0) 586 { 587 // TODO: We should look into sharing module based search filters 588 // across many breakpoints like we do for the simple target based one 589 filter_sp.reset (new SearchFilterByModuleList (shared_from_this(), *containingModules)); 590 } 591 else 592 { 593 if (!m_search_filter_sp) 594 m_search_filter_sp.reset (new SearchFilterForUnconstrainedSearches (shared_from_this())); 595 filter_sp = m_search_filter_sp; 596 } 597 return filter_sp; 598 } 599 600 SearchFilterSP 601 Target::GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules, 602 const FileSpecList *containingSourceFiles) 603 { 604 if (containingSourceFiles == nullptr || containingSourceFiles->GetSize() == 0) 605 return GetSearchFilterForModuleList(containingModules); 606 607 SearchFilterSP filter_sp; 608 if (containingModules == nullptr) 609 { 610 // We could make a special "CU List only SearchFilter". Better yet was if these could be composable, 611 // but that will take a little reworking. 612 613 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), FileSpecList(), *containingSourceFiles)); 614 } 615 else 616 { 617 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), *containingModules, *containingSourceFiles)); 618 } 619 return filter_sp; 620 } 621 622 BreakpointSP 623 Target::CreateFuncRegexBreakpoint (const FileSpecList *containingModules, 624 const FileSpecList *containingSourceFiles, 625 RegularExpression &func_regex, 626 lldb::LanguageType requested_language, 627 LazyBool skip_prologue, 628 bool internal, 629 bool hardware) 630 { 631 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 632 bool skip = 633 (skip_prologue == eLazyBoolCalculate) ? GetSkipPrologue() 634 : static_cast<bool>(skip_prologue); 635 BreakpointResolverSP resolver_sp(new BreakpointResolverName (nullptr, 636 func_regex, 637 requested_language, 638 0, 639 skip)); 640 641 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true); 642 } 643 644 lldb::BreakpointSP 645 Target::CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args, Error *error) 646 { 647 BreakpointSP exc_bkpt_sp = LanguageRuntime::CreateExceptionBreakpoint (*this, language, catch_bp, throw_bp, internal); 648 if (exc_bkpt_sp && additional_args) 649 { 650 Breakpoint::BreakpointPreconditionSP precondition_sp = exc_bkpt_sp->GetPrecondition(); 651 if (precondition_sp && additional_args) 652 { 653 if (error) 654 *error = precondition_sp->ConfigurePrecondition(*additional_args); 655 else 656 precondition_sp->ConfigurePrecondition(*additional_args); 657 } 658 } 659 return exc_bkpt_sp; 660 } 661 662 BreakpointSP 663 Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal, bool request_hardware, bool resolve_indirect_symbols) 664 { 665 BreakpointSP bp_sp; 666 if (filter_sp && resolver_sp) 667 { 668 bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp, request_hardware, resolve_indirect_symbols)); 669 resolver_sp->SetBreakpoint (bp_sp.get()); 670 AddBreakpoint (bp_sp, internal); 671 } 672 return bp_sp; 673 } 674 675 void 676 Target::AddBreakpoint (lldb::BreakpointSP bp_sp, bool internal) 677 { 678 if (!bp_sp) 679 return; 680 if (internal) 681 m_internal_breakpoint_list.Add (bp_sp, false); 682 else 683 m_breakpoint_list.Add (bp_sp, true); 684 685 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 686 if (log) 687 { 688 StreamString s; 689 bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 690 log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, bp_sp->IsInternal() ? "yes" : "no", s.GetData()); 691 } 692 693 bp_sp->ResolveBreakpoint(); 694 695 if (!internal) 696 { 697 m_last_created_breakpoint = bp_sp; 698 } 699 } 700 701 bool 702 Target::ProcessIsValid() 703 { 704 return (m_process_sp && m_process_sp->IsAlive()); 705 } 706 707 static bool 708 CheckIfWatchpointsExhausted(Target *target, Error &error) 709 { 710 uint32_t num_supported_hardware_watchpoints; 711 Error rc = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints); 712 if (num_supported_hardware_watchpoints == 0) 713 { 714 error.SetErrorStringWithFormat ("Target supports (%u) hardware watchpoint slots.\n", 715 num_supported_hardware_watchpoints); 716 return false; 717 } 718 return true; 719 } 720 721 // See also Watchpoint::SetWatchpointType(uint32_t type) and 722 // the OptionGroupWatchpoint::WatchType enum type. 723 WatchpointSP 724 Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Error &error) 725 { 726 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 727 if (log) 728 log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64 " type = %u)\n", 729 __FUNCTION__, addr, (uint64_t)size, kind); 730 731 WatchpointSP wp_sp; 732 if (!ProcessIsValid()) 733 { 734 error.SetErrorString("process is not alive"); 735 return wp_sp; 736 } 737 738 if (addr == LLDB_INVALID_ADDRESS || size == 0) 739 { 740 if (size == 0) 741 error.SetErrorString("cannot set a watchpoint with watch_size of 0"); 742 else 743 error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr); 744 return wp_sp; 745 } 746 747 if (!LLDB_WATCH_TYPE_IS_VALID(kind)) 748 { 749 error.SetErrorStringWithFormat ("invalid watchpoint type: %d", kind); 750 } 751 752 if (!CheckIfWatchpointsExhausted (this, error)) 753 return wp_sp; 754 755 // Currently we only support one watchpoint per address, with total number 756 // of watchpoints limited by the hardware which the inferior is running on. 757 758 // Grab the list mutex while doing operations. 759 const bool notify = false; // Don't notify about all the state changes we do on creating the watchpoint. 760 std::unique_lock<std::recursive_mutex> lock; 761 this->GetWatchpointList().GetListMutex(lock); 762 WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr); 763 if (matched_sp) 764 { 765 size_t old_size = matched_sp->GetByteSize(); 766 uint32_t old_type = 767 (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) | 768 (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0); 769 // Return the existing watchpoint if both size and type match. 770 if (size == old_size && kind == old_type) 771 { 772 wp_sp = matched_sp; 773 wp_sp->SetEnabled(false, notify); 774 } 775 else 776 { 777 // Nil the matched watchpoint; we will be creating a new one. 778 m_process_sp->DisableWatchpoint(matched_sp.get(), notify); 779 m_watchpoint_list.Remove(matched_sp->GetID(), true); 780 } 781 } 782 783 if (!wp_sp) 784 { 785 wp_sp.reset(new Watchpoint(*this, addr, size, type)); 786 wp_sp->SetWatchpointType(kind, notify); 787 m_watchpoint_list.Add (wp_sp, true); 788 } 789 790 error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify); 791 if (log) 792 log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n", 793 __FUNCTION__, 794 error.Success() ? "succeeded" : "failed", 795 wp_sp->GetID()); 796 797 if (error.Fail()) 798 { 799 // Enabling the watchpoint on the device side failed. 800 // Remove the said watchpoint from the list maintained by the target instance. 801 m_watchpoint_list.Remove (wp_sp->GetID(), true); 802 // See if we could provide more helpful error message. 803 if (!OptionGroupWatchpoint::IsWatchSizeSupported(size)) 804 error.SetErrorStringWithFormat("watch size of %" PRIu64 " is not supported", (uint64_t)size); 805 806 wp_sp.reset(); 807 } 808 else 809 m_last_created_watchpoint = wp_sp; 810 return wp_sp; 811 } 812 813 void 814 Target::RemoveAllBreakpoints (bool internal_also) 815 { 816 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 817 if (log) 818 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 819 820 m_breakpoint_list.RemoveAll (true); 821 if (internal_also) 822 m_internal_breakpoint_list.RemoveAll (false); 823 824 m_last_created_breakpoint.reset(); 825 } 826 827 void 828 Target::DisableAllBreakpoints (bool internal_also) 829 { 830 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 831 if (log) 832 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 833 834 m_breakpoint_list.SetEnabledAll (false); 835 if (internal_also) 836 m_internal_breakpoint_list.SetEnabledAll (false); 837 } 838 839 void 840 Target::EnableAllBreakpoints (bool internal_also) 841 { 842 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 843 if (log) 844 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 845 846 m_breakpoint_list.SetEnabledAll (true); 847 if (internal_also) 848 m_internal_breakpoint_list.SetEnabledAll (true); 849 } 850 851 bool 852 Target::RemoveBreakpointByID (break_id_t break_id) 853 { 854 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 855 if (log) 856 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 857 858 if (DisableBreakpointByID (break_id)) 859 { 860 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 861 m_internal_breakpoint_list.Remove(break_id, false); 862 else 863 { 864 if (m_last_created_breakpoint) 865 { 866 if (m_last_created_breakpoint->GetID() == break_id) 867 m_last_created_breakpoint.reset(); 868 } 869 m_breakpoint_list.Remove(break_id, true); 870 } 871 return true; 872 } 873 return false; 874 } 875 876 bool 877 Target::DisableBreakpointByID (break_id_t break_id) 878 { 879 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 880 if (log) 881 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 882 883 BreakpointSP bp_sp; 884 885 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 886 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 887 else 888 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 889 if (bp_sp) 890 { 891 bp_sp->SetEnabled (false); 892 return true; 893 } 894 return false; 895 } 896 897 bool 898 Target::EnableBreakpointByID (break_id_t break_id) 899 { 900 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 901 if (log) 902 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", 903 __FUNCTION__, 904 break_id, 905 LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 906 907 BreakpointSP bp_sp; 908 909 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 910 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 911 else 912 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 913 914 if (bp_sp) 915 { 916 bp_sp->SetEnabled (true); 917 return true; 918 } 919 return false; 920 } 921 922 // The flag 'end_to_end', default to true, signifies that the operation is 923 // performed end to end, for both the debugger and the debuggee. 924 925 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end 926 // to end operations. 927 bool 928 Target::RemoveAllWatchpoints (bool end_to_end) 929 { 930 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 931 if (log) 932 log->Printf ("Target::%s\n", __FUNCTION__); 933 934 if (!end_to_end) { 935 m_watchpoint_list.RemoveAll(true); 936 return true; 937 } 938 939 // Otherwise, it's an end to end operation. 940 941 if (!ProcessIsValid()) 942 return false; 943 944 size_t num_watchpoints = m_watchpoint_list.GetSize(); 945 for (size_t i = 0; i < num_watchpoints; ++i) 946 { 947 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 948 if (!wp_sp) 949 return false; 950 951 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 952 if (rc.Fail()) 953 return false; 954 } 955 m_watchpoint_list.RemoveAll (true); 956 m_last_created_watchpoint.reset(); 957 return true; // Success! 958 } 959 960 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to 961 // end operations. 962 bool 963 Target::DisableAllWatchpoints (bool end_to_end) 964 { 965 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 966 if (log) 967 log->Printf ("Target::%s\n", __FUNCTION__); 968 969 if (!end_to_end) { 970 m_watchpoint_list.SetEnabledAll(false); 971 return true; 972 } 973 974 // Otherwise, it's an end to end operation. 975 976 if (!ProcessIsValid()) 977 return false; 978 979 size_t num_watchpoints = m_watchpoint_list.GetSize(); 980 for (size_t i = 0; i < num_watchpoints; ++i) 981 { 982 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 983 if (!wp_sp) 984 return false; 985 986 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 987 if (rc.Fail()) 988 return false; 989 } 990 return true; // Success! 991 } 992 993 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to 994 // end operations. 995 bool 996 Target::EnableAllWatchpoints (bool end_to_end) 997 { 998 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 999 if (log) 1000 log->Printf ("Target::%s\n", __FUNCTION__); 1001 1002 if (!end_to_end) { 1003 m_watchpoint_list.SetEnabledAll(true); 1004 return true; 1005 } 1006 1007 // Otherwise, it's an end to end operation. 1008 1009 if (!ProcessIsValid()) 1010 return false; 1011 1012 size_t num_watchpoints = m_watchpoint_list.GetSize(); 1013 for (size_t i = 0; i < num_watchpoints; ++i) 1014 { 1015 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 1016 if (!wp_sp) 1017 return false; 1018 1019 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get()); 1020 if (rc.Fail()) 1021 return false; 1022 } 1023 return true; // Success! 1024 } 1025 1026 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 1027 bool 1028 Target::ClearAllWatchpointHitCounts () 1029 { 1030 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1031 if (log) 1032 log->Printf ("Target::%s\n", __FUNCTION__); 1033 1034 size_t num_watchpoints = m_watchpoint_list.GetSize(); 1035 for (size_t i = 0; i < num_watchpoints; ++i) 1036 { 1037 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 1038 if (!wp_sp) 1039 return false; 1040 1041 wp_sp->ResetHitCount(); 1042 } 1043 return true; // Success! 1044 } 1045 1046 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 1047 bool 1048 Target::ClearAllWatchpointHistoricValues () 1049 { 1050 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1051 if (log) 1052 log->Printf ("Target::%s\n", __FUNCTION__); 1053 1054 size_t num_watchpoints = m_watchpoint_list.GetSize(); 1055 for (size_t i = 0; i < num_watchpoints; ++i) 1056 { 1057 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 1058 if (!wp_sp) 1059 return false; 1060 1061 wp_sp->ResetHistoricValues(); 1062 } 1063 return true; // Success! 1064 } 1065 1066 // Assumption: Caller holds the list mutex lock for m_watchpoint_list 1067 // during these operations. 1068 bool 1069 Target::IgnoreAllWatchpoints (uint32_t ignore_count) 1070 { 1071 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1072 if (log) 1073 log->Printf ("Target::%s\n", __FUNCTION__); 1074 1075 if (!ProcessIsValid()) 1076 return false; 1077 1078 size_t num_watchpoints = m_watchpoint_list.GetSize(); 1079 for (size_t i = 0; i < num_watchpoints; ++i) 1080 { 1081 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 1082 if (!wp_sp) 1083 return false; 1084 1085 wp_sp->SetIgnoreCount(ignore_count); 1086 } 1087 return true; // Success! 1088 } 1089 1090 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 1091 bool 1092 Target::DisableWatchpointByID (lldb::watch_id_t watch_id) 1093 { 1094 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1095 if (log) 1096 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 1097 1098 if (!ProcessIsValid()) 1099 return false; 1100 1101 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 1102 if (wp_sp) 1103 { 1104 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 1105 if (rc.Success()) 1106 return true; 1107 1108 // Else, fallthrough. 1109 } 1110 return false; 1111 } 1112 1113 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 1114 bool 1115 Target::EnableWatchpointByID (lldb::watch_id_t watch_id) 1116 { 1117 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1118 if (log) 1119 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 1120 1121 if (!ProcessIsValid()) 1122 return false; 1123 1124 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 1125 if (wp_sp) 1126 { 1127 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get()); 1128 if (rc.Success()) 1129 return true; 1130 1131 // Else, fallthrough. 1132 } 1133 return false; 1134 } 1135 1136 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 1137 bool 1138 Target::RemoveWatchpointByID (lldb::watch_id_t watch_id) 1139 { 1140 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1141 if (log) 1142 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 1143 1144 WatchpointSP watch_to_remove_sp = m_watchpoint_list.FindByID(watch_id); 1145 if (watch_to_remove_sp == m_last_created_watchpoint) 1146 m_last_created_watchpoint.reset(); 1147 1148 if (DisableWatchpointByID (watch_id)) 1149 { 1150 m_watchpoint_list.Remove(watch_id, true); 1151 return true; 1152 } 1153 return false; 1154 } 1155 1156 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 1157 bool 1158 Target::IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count) 1159 { 1160 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 1161 if (log) 1162 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 1163 1164 if (!ProcessIsValid()) 1165 return false; 1166 1167 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 1168 if (wp_sp) 1169 { 1170 wp_sp->SetIgnoreCount(ignore_count); 1171 return true; 1172 } 1173 return false; 1174 } 1175 1176 ModuleSP 1177 Target::GetExecutableModule () 1178 { 1179 // search for the first executable in the module list 1180 for (size_t i = 0; i < m_images.GetSize(); ++i) 1181 { 1182 ModuleSP module_sp = m_images.GetModuleAtIndex (i); 1183 lldb_private::ObjectFile * obj = module_sp->GetObjectFile(); 1184 if (obj == nullptr) 1185 continue; 1186 if (obj->GetType() == ObjectFile::Type::eTypeExecutable) 1187 return module_sp; 1188 } 1189 // as fall back return the first module loaded 1190 return m_images.GetModuleAtIndex (0); 1191 } 1192 1193 Module* 1194 Target::GetExecutableModulePointer () 1195 { 1196 return GetExecutableModule().get(); 1197 } 1198 1199 static void 1200 LoadScriptingResourceForModule (const ModuleSP &module_sp, Target *target) 1201 { 1202 Error error; 1203 StreamString feedback_stream; 1204 if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error, &feedback_stream)) 1205 { 1206 if (error.AsCString()) 1207 target->GetDebugger().GetErrorFile()->Printf("unable to load scripting data for module %s - error reported was %s\n", 1208 module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(), 1209 error.AsCString()); 1210 } 1211 if (feedback_stream.GetSize()) 1212 target->GetDebugger().GetErrorFile()->Printf("%s\n", 1213 feedback_stream.GetData()); 1214 } 1215 1216 void 1217 Target::ClearModules(bool delete_locations) 1218 { 1219 ModulesDidUnload (m_images, delete_locations); 1220 m_section_load_history.Clear(); 1221 m_images.Clear(); 1222 m_scratch_type_system_map.Clear(); 1223 m_ast_importer_sp.reset(); 1224 } 1225 1226 void 1227 Target::DidExec () 1228 { 1229 // When a process exec's we need to know about it so we can do some cleanup. 1230 m_breakpoint_list.RemoveInvalidLocations(m_arch); 1231 m_internal_breakpoint_list.RemoveInvalidLocations(m_arch); 1232 } 1233 1234 void 1235 Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files) 1236 { 1237 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 1238 ClearModules(false); 1239 1240 if (executable_sp) 1241 { 1242 Timer scoped_timer (LLVM_PRETTY_FUNCTION, 1243 "Target::SetExecutableModule (executable = '%s')", 1244 executable_sp->GetFileSpec().GetPath().c_str()); 1245 1246 m_images.Append(executable_sp); // The first image is our executable file 1247 1248 // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module. 1249 if (!m_arch.IsValid()) 1250 { 1251 m_arch = executable_sp->GetArchitecture(); 1252 if (log) 1253 log->Printf ("Target::SetExecutableModule setting architecture to %s (%s) based on executable file", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 1254 } 1255 1256 FileSpecList dependent_files; 1257 ObjectFile *executable_objfile = executable_sp->GetObjectFile(); 1258 1259 if (executable_objfile && get_dependent_files) 1260 { 1261 executable_objfile->GetDependentModules(dependent_files); 1262 for (uint32_t i=0; i<dependent_files.GetSize(); i++) 1263 { 1264 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i)); 1265 FileSpec platform_dependent_file_spec; 1266 if (m_platform_sp) 1267 m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr, platform_dependent_file_spec); 1268 else 1269 platform_dependent_file_spec = dependent_file_spec; 1270 1271 ModuleSpec module_spec (platform_dependent_file_spec, m_arch); 1272 ModuleSP image_module_sp(GetSharedModule (module_spec)); 1273 if (image_module_sp) 1274 { 1275 ObjectFile *objfile = image_module_sp->GetObjectFile(); 1276 if (objfile) 1277 objfile->GetDependentModules(dependent_files); 1278 } 1279 } 1280 } 1281 } 1282 } 1283 1284 bool 1285 Target::SetArchitecture (const ArchSpec &arch_spec) 1286 { 1287 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 1288 bool missing_local_arch = !m_arch.IsValid(); 1289 bool replace_local_arch = true; 1290 bool compatible_local_arch = false; 1291 ArchSpec other(arch_spec); 1292 1293 if (!missing_local_arch) 1294 { 1295 if (m_arch.IsCompatibleMatch(arch_spec)) 1296 { 1297 other.MergeFrom(m_arch); 1298 1299 if (m_arch.IsCompatibleMatch(other)) 1300 { 1301 compatible_local_arch = true; 1302 bool arch_changed, vendor_changed, os_changed, os_ver_changed, env_changed; 1303 1304 m_arch.PiecewiseTripleCompare(other, 1305 arch_changed, 1306 vendor_changed, 1307 os_changed, 1308 os_ver_changed, 1309 env_changed); 1310 1311 if (!arch_changed && !vendor_changed && !os_changed && !env_changed) 1312 replace_local_arch = false; 1313 } 1314 } 1315 } 1316 1317 if (compatible_local_arch || missing_local_arch) 1318 { 1319 // If we haven't got a valid arch spec, or the architectures are compatible 1320 // update the architecture, unless the one we already have is more specified 1321 if (replace_local_arch) 1322 m_arch = other; 1323 if (log) 1324 log->Printf ("Target::SetArchitecture set architecture to %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 1325 return true; 1326 } 1327 1328 // If we have an executable file, try to reset the executable to the desired architecture 1329 if (log) 1330 log->Printf ("Target::SetArchitecture changing architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1331 m_arch = other; 1332 ModuleSP executable_sp = GetExecutableModule (); 1333 1334 ClearModules(true); 1335 // Need to do something about unsetting breakpoints. 1336 1337 if (executable_sp) 1338 { 1339 if (log) 1340 log->Printf("Target::SetArchitecture Trying to select executable file architecture %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1341 ModuleSpec module_spec (executable_sp->GetFileSpec(), other); 1342 Error error = ModuleList::GetSharedModule(module_spec, 1343 executable_sp, 1344 &GetExecutableSearchPaths(), 1345 nullptr, 1346 nullptr); 1347 1348 if (!error.Fail() && executable_sp) 1349 { 1350 SetExecutableModule (executable_sp, true); 1351 return true; 1352 } 1353 } 1354 return false; 1355 } 1356 1357 bool 1358 Target::MergeArchitecture (const ArchSpec &arch_spec) 1359 { 1360 if (arch_spec.IsValid()) 1361 { 1362 if (m_arch.IsCompatibleMatch(arch_spec)) 1363 { 1364 // The current target arch is compatible with "arch_spec", see if we 1365 // can improve our current architecture using bits from "arch_spec" 1366 1367 // Merge bits from arch_spec into "merged_arch" and set our architecture 1368 ArchSpec merged_arch (m_arch); 1369 merged_arch.MergeFrom (arch_spec); 1370 return SetArchitecture(merged_arch); 1371 } 1372 else 1373 { 1374 // The new architecture is different, we just need to replace it 1375 return SetArchitecture(arch_spec); 1376 } 1377 } 1378 return false; 1379 } 1380 1381 void 1382 Target::WillClearList (const ModuleList& module_list) 1383 { 1384 } 1385 1386 void 1387 Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp) 1388 { 1389 // A module is being added to this target for the first time 1390 if (m_valid) 1391 { 1392 ModuleList my_module_list; 1393 my_module_list.Append(module_sp); 1394 LoadScriptingResourceForModule(module_sp, this); 1395 ModulesDidLoad (my_module_list); 1396 } 1397 } 1398 1399 void 1400 Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp) 1401 { 1402 // A module is being removed from this target. 1403 if (m_valid) 1404 { 1405 ModuleList my_module_list; 1406 my_module_list.Append(module_sp); 1407 ModulesDidUnload (my_module_list, false); 1408 } 1409 } 1410 1411 void 1412 Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp) 1413 { 1414 // A module is replacing an already added module 1415 if (m_valid) 1416 { 1417 m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp); 1418 m_internal_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp); 1419 } 1420 } 1421 1422 void 1423 Target::ModulesDidLoad (ModuleList &module_list) 1424 { 1425 if (m_valid && module_list.GetSize()) 1426 { 1427 m_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1428 m_internal_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1429 if (m_process_sp) 1430 { 1431 m_process_sp->ModulesDidLoad (module_list); 1432 } 1433 BroadcastEvent (eBroadcastBitModulesLoaded, new TargetEventData (this->shared_from_this(), module_list)); 1434 } 1435 } 1436 1437 void 1438 Target::SymbolsDidLoad (ModuleList &module_list) 1439 { 1440 if (m_valid && module_list.GetSize()) 1441 { 1442 if (m_process_sp) 1443 { 1444 LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); 1445 if (runtime) 1446 { 1447 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime; 1448 objc_runtime->SymbolsDidLoad(module_list); 1449 } 1450 } 1451 1452 m_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1453 m_internal_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1454 BroadcastEvent (eBroadcastBitSymbolsLoaded, new TargetEventData (this->shared_from_this(), module_list)); 1455 } 1456 } 1457 1458 void 1459 Target::ModulesDidUnload (ModuleList &module_list, bool delete_locations) 1460 { 1461 if (m_valid && module_list.GetSize()) 1462 { 1463 UnloadModuleSections (module_list); 1464 m_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations); 1465 m_internal_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations); 1466 BroadcastEvent (eBroadcastBitModulesUnloaded, new TargetEventData (this->shared_from_this(), module_list)); 1467 } 1468 } 1469 1470 bool 1471 Target::ModuleIsExcludedForUnconstrainedSearches (const FileSpec &module_file_spec) 1472 { 1473 if (GetBreakpointsConsultPlatformAvoidList()) 1474 { 1475 ModuleList matchingModules; 1476 ModuleSpec module_spec (module_file_spec); 1477 size_t num_modules = GetImages().FindModules(module_spec, matchingModules); 1478 1479 // If there is more than one module for this file spec, only return true if ALL the modules are on the 1480 // black list. 1481 if (num_modules > 0) 1482 { 1483 for (size_t i = 0; i < num_modules; i++) 1484 { 1485 if (!ModuleIsExcludedForUnconstrainedSearches (matchingModules.GetModuleAtIndex(i))) 1486 return false; 1487 } 1488 return true; 1489 } 1490 } 1491 return false; 1492 } 1493 1494 bool 1495 Target::ModuleIsExcludedForUnconstrainedSearches (const lldb::ModuleSP &module_sp) 1496 { 1497 if (GetBreakpointsConsultPlatformAvoidList()) 1498 { 1499 if (m_platform_sp) 1500 return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches (*this, module_sp); 1501 } 1502 return false; 1503 } 1504 1505 size_t 1506 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error) 1507 { 1508 SectionSP section_sp (addr.GetSection()); 1509 if (section_sp) 1510 { 1511 // If the contents of this section are encrypted, the on-disk file is unusable. Read only from live memory. 1512 if (section_sp->IsEncrypted()) 1513 { 1514 error.SetErrorString("section is encrypted"); 1515 return 0; 1516 } 1517 ModuleSP module_sp (section_sp->GetModule()); 1518 if (module_sp) 1519 { 1520 ObjectFile *objfile = section_sp->GetModule()->GetObjectFile(); 1521 if (objfile) 1522 { 1523 size_t bytes_read = objfile->ReadSectionData (section_sp.get(), 1524 addr.GetOffset(), 1525 dst, 1526 dst_len); 1527 if (bytes_read > 0) 1528 return bytes_read; 1529 else 1530 error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString()); 1531 } 1532 else 1533 error.SetErrorString("address isn't from a object file"); 1534 } 1535 else 1536 error.SetErrorString("address isn't in a module"); 1537 } 1538 else 1539 error.SetErrorString("address doesn't contain a section that points to a section in a object file"); 1540 1541 return 0; 1542 } 1543 1544 size_t 1545 Target::ReadMemory (const Address& addr, 1546 bool prefer_file_cache, 1547 void *dst, 1548 size_t dst_len, 1549 Error &error, 1550 lldb::addr_t *load_addr_ptr) 1551 { 1552 error.Clear(); 1553 1554 // if we end up reading this from process memory, we will fill this 1555 // with the actual load address 1556 if (load_addr_ptr) 1557 *load_addr_ptr = LLDB_INVALID_ADDRESS; 1558 1559 size_t bytes_read = 0; 1560 1561 addr_t load_addr = LLDB_INVALID_ADDRESS; 1562 addr_t file_addr = LLDB_INVALID_ADDRESS; 1563 Address resolved_addr; 1564 if (!addr.IsSectionOffset()) 1565 { 1566 SectionLoadList §ion_load_list = GetSectionLoadList(); 1567 if (section_load_list.IsEmpty()) 1568 { 1569 // No sections are loaded, so we must assume we are not running 1570 // yet and anything we are given is a file address. 1571 file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address 1572 m_images.ResolveFileAddress (file_addr, resolved_addr); 1573 } 1574 else 1575 { 1576 // We have at least one section loaded. This can be because 1577 // we have manually loaded some sections with "target modules load ..." 1578 // or because we have have a live process that has sections loaded 1579 // through the dynamic loader 1580 load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address 1581 section_load_list.ResolveLoadAddress (load_addr, resolved_addr); 1582 } 1583 } 1584 if (!resolved_addr.IsValid()) 1585 resolved_addr = addr; 1586 1587 if (prefer_file_cache) 1588 { 1589 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1590 if (bytes_read > 0) 1591 return bytes_read; 1592 } 1593 1594 if (ProcessIsValid()) 1595 { 1596 if (load_addr == LLDB_INVALID_ADDRESS) 1597 load_addr = resolved_addr.GetLoadAddress (this); 1598 1599 if (load_addr == LLDB_INVALID_ADDRESS) 1600 { 1601 ModuleSP addr_module_sp (resolved_addr.GetModule()); 1602 if (addr_module_sp && addr_module_sp->GetFileSpec()) 1603 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded", 1604 addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"), 1605 resolved_addr.GetFileAddress(), 1606 addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknonw>")); 1607 else 1608 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress()); 1609 } 1610 else 1611 { 1612 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error); 1613 if (bytes_read != dst_len) 1614 { 1615 if (error.Success()) 1616 { 1617 if (bytes_read == 0) 1618 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr); 1619 else 1620 error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr); 1621 } 1622 } 1623 if (bytes_read) 1624 { 1625 if (load_addr_ptr) 1626 *load_addr_ptr = load_addr; 1627 return bytes_read; 1628 } 1629 // If the address is not section offset we have an address that 1630 // doesn't resolve to any address in any currently loaded shared 1631 // libraries and we failed to read memory so there isn't anything 1632 // more we can do. If it is section offset, we might be able to 1633 // read cached memory from the object file. 1634 if (!resolved_addr.IsSectionOffset()) 1635 return 0; 1636 } 1637 } 1638 1639 if (!prefer_file_cache && resolved_addr.IsSectionOffset()) 1640 { 1641 // If we didn't already try and read from the object file cache, then 1642 // try it after failing to read from the process. 1643 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1644 } 1645 return 0; 1646 } 1647 1648 size_t 1649 Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error) 1650 { 1651 char buf[256]; 1652 out_str.clear(); 1653 addr_t curr_addr = addr.GetLoadAddress(this); 1654 Address address(addr); 1655 while (1) 1656 { 1657 size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error); 1658 if (length == 0) 1659 break; 1660 out_str.append(buf, length); 1661 // If we got "length - 1" bytes, we didn't get the whole C string, we 1662 // need to read some more characters 1663 if (length == sizeof(buf) - 1) 1664 curr_addr += length; 1665 else 1666 break; 1667 address = Address(curr_addr); 1668 } 1669 return out_str.size(); 1670 } 1671 1672 size_t 1673 Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error) 1674 { 1675 size_t total_cstr_len = 0; 1676 if (dst && dst_max_len) 1677 { 1678 result_error.Clear(); 1679 // NULL out everything just to be safe 1680 memset (dst, 0, dst_max_len); 1681 Error error; 1682 addr_t curr_addr = addr.GetLoadAddress(this); 1683 Address address(addr); 1684 1685 // We could call m_process_sp->GetMemoryCacheLineSize() but I don't 1686 // think this really needs to be tied to the memory cache subsystem's 1687 // cache line size, so leave this as a fixed constant. 1688 const size_t cache_line_size = 512; 1689 1690 size_t bytes_left = dst_max_len - 1; 1691 char *curr_dst = dst; 1692 1693 while (bytes_left > 0) 1694 { 1695 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size); 1696 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left); 1697 size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error); 1698 1699 if (bytes_read == 0) 1700 { 1701 result_error = error; 1702 dst[total_cstr_len] = '\0'; 1703 break; 1704 } 1705 const size_t len = strlen(curr_dst); 1706 1707 total_cstr_len += len; 1708 1709 if (len < bytes_to_read) 1710 break; 1711 1712 curr_dst += bytes_read; 1713 curr_addr += bytes_read; 1714 bytes_left -= bytes_read; 1715 address = Address(curr_addr); 1716 } 1717 } 1718 else 1719 { 1720 if (dst == nullptr) 1721 result_error.SetErrorString("invalid arguments"); 1722 else 1723 result_error.Clear(); 1724 } 1725 return total_cstr_len; 1726 } 1727 1728 size_t 1729 Target::ReadScalarIntegerFromMemory (const Address& addr, 1730 bool prefer_file_cache, 1731 uint32_t byte_size, 1732 bool is_signed, 1733 Scalar &scalar, 1734 Error &error) 1735 { 1736 uint64_t uval; 1737 1738 if (byte_size <= sizeof(uval)) 1739 { 1740 size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error); 1741 if (bytes_read == byte_size) 1742 { 1743 DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize()); 1744 lldb::offset_t offset = 0; 1745 if (byte_size <= 4) 1746 scalar = data.GetMaxU32 (&offset, byte_size); 1747 else 1748 scalar = data.GetMaxU64 (&offset, byte_size); 1749 1750 if (is_signed) 1751 scalar.SignExtend(byte_size * 8); 1752 return bytes_read; 1753 } 1754 } 1755 else 1756 { 1757 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size); 1758 } 1759 return 0; 1760 } 1761 1762 uint64_t 1763 Target::ReadUnsignedIntegerFromMemory (const Address& addr, 1764 bool prefer_file_cache, 1765 size_t integer_byte_size, 1766 uint64_t fail_value, 1767 Error &error) 1768 { 1769 Scalar scalar; 1770 if (ReadScalarIntegerFromMemory (addr, 1771 prefer_file_cache, 1772 integer_byte_size, 1773 false, 1774 scalar, 1775 error)) 1776 return scalar.ULongLong(fail_value); 1777 return fail_value; 1778 } 1779 1780 bool 1781 Target::ReadPointerFromMemory (const Address& addr, 1782 bool prefer_file_cache, 1783 Error &error, 1784 Address &pointer_addr) 1785 { 1786 Scalar scalar; 1787 if (ReadScalarIntegerFromMemory (addr, 1788 prefer_file_cache, 1789 m_arch.GetAddressByteSize(), 1790 false, 1791 scalar, 1792 error)) 1793 { 1794 addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS); 1795 if (pointer_vm_addr != LLDB_INVALID_ADDRESS) 1796 { 1797 SectionLoadList §ion_load_list = GetSectionLoadList(); 1798 if (section_load_list.IsEmpty()) 1799 { 1800 // No sections are loaded, so we must assume we are not running 1801 // yet and anything we are given is a file address. 1802 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr); 1803 } 1804 else 1805 { 1806 // We have at least one section loaded. This can be because 1807 // we have manually loaded some sections with "target modules load ..." 1808 // or because we have have a live process that has sections loaded 1809 // through the dynamic loader 1810 section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr); 1811 } 1812 // We weren't able to resolve the pointer value, so just return 1813 // an address with no section 1814 if (!pointer_addr.IsValid()) 1815 pointer_addr.SetOffset (pointer_vm_addr); 1816 return true; 1817 1818 } 1819 } 1820 return false; 1821 } 1822 1823 ModuleSP 1824 Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr) 1825 { 1826 ModuleSP module_sp; 1827 1828 Error error; 1829 1830 // First see if we already have this module in our module list. If we do, then we're done, we don't need 1831 // to consult the shared modules list. But only do this if we are passed a UUID. 1832 1833 if (module_spec.GetUUID().IsValid()) 1834 module_sp = m_images.FindFirstModule(module_spec); 1835 1836 if (!module_sp) 1837 { 1838 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library 1839 bool did_create_module = false; 1840 1841 // If there are image search path entries, try to use them first to acquire a suitable image. 1842 if (m_image_search_paths.GetSize()) 1843 { 1844 ModuleSpec transformed_spec (module_spec); 1845 if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory())) 1846 { 1847 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename(); 1848 error = ModuleList::GetSharedModule (transformed_spec, 1849 module_sp, 1850 &GetExecutableSearchPaths(), 1851 &old_module_sp, 1852 &did_create_module); 1853 } 1854 } 1855 1856 if (!module_sp) 1857 { 1858 // If we have a UUID, we can check our global shared module list in case 1859 // we already have it. If we don't have a valid UUID, then we can't since 1860 // the path in "module_spec" will be a platform path, and we will need to 1861 // let the platform find that file. For example, we could be asking for 1862 // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick 1863 // the local copy of "/usr/lib/dyld" since our platform could be a remote 1864 // platform that has its own "/usr/lib/dyld" in an SDK or in a local file 1865 // cache. 1866 if (module_spec.GetUUID().IsValid()) 1867 { 1868 // We have a UUID, it is OK to check the global module list... 1869 error = ModuleList::GetSharedModule (module_spec, 1870 module_sp, 1871 &GetExecutableSearchPaths(), 1872 &old_module_sp, 1873 &did_create_module); 1874 } 1875 1876 if (!module_sp) 1877 { 1878 // The platform is responsible for finding and caching an appropriate 1879 // module in the shared module cache. 1880 if (m_platform_sp) 1881 { 1882 error = m_platform_sp->GetSharedModule (module_spec, 1883 m_process_sp.get(), 1884 module_sp, 1885 &GetExecutableSearchPaths(), 1886 &old_module_sp, 1887 &did_create_module); 1888 } 1889 else 1890 { 1891 error.SetErrorString("no platform is currently set"); 1892 } 1893 } 1894 } 1895 1896 // We found a module that wasn't in our target list. Let's make sure that there wasn't an equivalent 1897 // module in the list already, and if there was, let's remove it. 1898 if (module_sp) 1899 { 1900 ObjectFile *objfile = module_sp->GetObjectFile(); 1901 if (objfile) 1902 { 1903 switch (objfile->GetType()) 1904 { 1905 case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of a program's execution state 1906 case ObjectFile::eTypeExecutable: /// A normal executable 1907 case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable 1908 case ObjectFile::eTypeObjectFile: /// An intermediate object file 1909 case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution 1910 break; 1911 case ObjectFile::eTypeDebugInfo: /// An object file that contains only debug information 1912 if (error_ptr) 1913 error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable"); 1914 return ModuleSP(); 1915 case ObjectFile::eTypeStubLibrary: /// A library that can be linked against but not used for execution 1916 if (error_ptr) 1917 error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable"); 1918 return ModuleSP(); 1919 default: 1920 if (error_ptr) 1921 error_ptr->SetErrorString("unsupported file type, please specify an executable"); 1922 return ModuleSP(); 1923 } 1924 // GetSharedModule is not guaranteed to find the old shared module, for instance 1925 // in the common case where you pass in the UUID, it is only going to find the one 1926 // module matching the UUID. In fact, it has no good way to know what the "old module" 1927 // relevant to this target is, since there might be many copies of a module with this file spec 1928 // in various running debug sessions, but only one of them will belong to this target. 1929 // So let's remove the UUID from the module list, and look in the target's module list. 1930 // Only do this if there is SOMETHING else in the module spec... 1931 if (!old_module_sp) 1932 { 1933 if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty()) 1934 { 1935 ModuleSpec module_spec_copy(module_spec.GetFileSpec()); 1936 module_spec_copy.GetUUID().Clear(); 1937 1938 ModuleList found_modules; 1939 size_t num_found = m_images.FindModules (module_spec_copy, found_modules); 1940 if (num_found == 1) 1941 { 1942 old_module_sp = found_modules.GetModuleAtIndex(0); 1943 } 1944 } 1945 } 1946 1947 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32) 1948 { 1949 m_images.ReplaceModule(old_module_sp, module_sp); 1950 Module *old_module_ptr = old_module_sp.get(); 1951 old_module_sp.reset(); 1952 ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr); 1953 } 1954 else 1955 m_images.Append(module_sp); 1956 } 1957 else 1958 module_sp.reset(); 1959 } 1960 } 1961 if (error_ptr) 1962 *error_ptr = error; 1963 return module_sp; 1964 } 1965 1966 TargetSP 1967 Target::CalculateTarget () 1968 { 1969 return shared_from_this(); 1970 } 1971 1972 ProcessSP 1973 Target::CalculateProcess () 1974 { 1975 return m_process_sp; 1976 } 1977 1978 ThreadSP 1979 Target::CalculateThread () 1980 { 1981 return ThreadSP(); 1982 } 1983 1984 StackFrameSP 1985 Target::CalculateStackFrame () 1986 { 1987 return StackFrameSP(); 1988 } 1989 1990 void 1991 Target::CalculateExecutionContext (ExecutionContext &exe_ctx) 1992 { 1993 exe_ctx.Clear(); 1994 exe_ctx.SetTargetPtr(this); 1995 } 1996 1997 PathMappingList & 1998 Target::GetImageSearchPathList () 1999 { 2000 return m_image_search_paths; 2001 } 2002 2003 void 2004 Target::ImageSearchPathsChanged(const PathMappingList &path_list, 2005 void *baton) 2006 { 2007 Target *target = (Target *)baton; 2008 ModuleSP exe_module_sp (target->GetExecutableModule()); 2009 if (exe_module_sp) 2010 target->SetExecutableModule (exe_module_sp, true); 2011 } 2012 2013 TypeSystem * 2014 Target::GetScratchTypeSystemForLanguage (Error *error, lldb::LanguageType language, bool create_on_demand) 2015 { 2016 if (!m_valid) 2017 return nullptr; 2018 2019 if (error) 2020 { 2021 error->Clear(); 2022 } 2023 2024 if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all assembly code 2025 || language == eLanguageTypeUnknown) 2026 { 2027 std::set<lldb::LanguageType> languages_for_types; 2028 std::set<lldb::LanguageType> languages_for_expressions; 2029 2030 Language::GetLanguagesSupportingTypeSystems(languages_for_types, languages_for_expressions); 2031 2032 if (languages_for_expressions.count(eLanguageTypeC)) 2033 { 2034 language = eLanguageTypeC; // LLDB's default. Override by setting the target language. 2035 } 2036 else 2037 { 2038 if (languages_for_expressions.empty()) 2039 { 2040 return nullptr; 2041 } 2042 else 2043 { 2044 language = *languages_for_expressions.begin(); 2045 } 2046 } 2047 } 2048 2049 return m_scratch_type_system_map.GetTypeSystemForLanguage(language, this, create_on_demand); 2050 } 2051 2052 PersistentExpressionState * 2053 Target::GetPersistentExpressionStateForLanguage (lldb::LanguageType language) 2054 { 2055 TypeSystem *type_system = GetScratchTypeSystemForLanguage(nullptr, language, true); 2056 2057 if (type_system) 2058 { 2059 return type_system->GetPersistentExpressionState(); 2060 } 2061 else 2062 { 2063 return nullptr; 2064 } 2065 } 2066 2067 UserExpression * 2068 Target::GetUserExpressionForLanguage(const char *expr, 2069 const char *expr_prefix, 2070 lldb::LanguageType language, 2071 Expression::ResultType desired_type, 2072 const EvaluateExpressionOptions &options, 2073 Error &error) 2074 { 2075 Error type_system_error; 2076 2077 TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language); 2078 UserExpression *user_expr = nullptr; 2079 2080 if (!type_system) 2081 { 2082 error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString()); 2083 return nullptr; 2084 } 2085 2086 user_expr = type_system->GetUserExpression(expr, expr_prefix, language, desired_type, options); 2087 if (!user_expr) 2088 error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language)); 2089 2090 return user_expr; 2091 } 2092 2093 FunctionCaller * 2094 Target::GetFunctionCallerForLanguage (lldb::LanguageType language, 2095 const CompilerType &return_type, 2096 const Address& function_address, 2097 const ValueList &arg_value_list, 2098 const char *name, 2099 Error &error) 2100 { 2101 Error type_system_error; 2102 TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language); 2103 FunctionCaller *persistent_fn = nullptr; 2104 2105 if (!type_system) 2106 { 2107 error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString()); 2108 return persistent_fn; 2109 } 2110 2111 persistent_fn = type_system->GetFunctionCaller (return_type, function_address, arg_value_list, name); 2112 if (!persistent_fn) 2113 error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language)); 2114 2115 return persistent_fn; 2116 } 2117 2118 UtilityFunction * 2119 Target::GetUtilityFunctionForLanguage (const char *text, 2120 lldb::LanguageType language, 2121 const char *name, 2122 Error &error) 2123 { 2124 Error type_system_error; 2125 TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language); 2126 UtilityFunction *utility_fn = nullptr; 2127 2128 if (!type_system) 2129 { 2130 error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString()); 2131 return utility_fn; 2132 } 2133 2134 utility_fn = type_system->GetUtilityFunction (text, name); 2135 if (!utility_fn) 2136 error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language)); 2137 2138 return utility_fn; 2139 } 2140 2141 ClangASTContext * 2142 Target::GetScratchClangASTContext(bool create_on_demand) 2143 { 2144 if (m_valid) 2145 { 2146 if (TypeSystem* type_system = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC, create_on_demand)) 2147 return llvm::dyn_cast<ClangASTContext>(type_system); 2148 } 2149 return nullptr; 2150 } 2151 2152 ClangASTImporterSP 2153 Target::GetClangASTImporter() 2154 { 2155 if (m_valid) 2156 { 2157 if (!m_ast_importer_sp) 2158 { 2159 m_ast_importer_sp.reset(new ClangASTImporter()); 2160 } 2161 return m_ast_importer_sp; 2162 } 2163 return ClangASTImporterSP(); 2164 } 2165 2166 void 2167 Target::SettingsInitialize () 2168 { 2169 Process::SettingsInitialize (); 2170 } 2171 2172 void 2173 Target::SettingsTerminate () 2174 { 2175 Process::SettingsTerminate (); 2176 } 2177 2178 FileSpecList 2179 Target::GetDefaultExecutableSearchPaths () 2180 { 2181 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 2182 if (properties_sp) 2183 return properties_sp->GetExecutableSearchPaths(); 2184 return FileSpecList(); 2185 } 2186 2187 FileSpecList 2188 Target::GetDefaultDebugFileSearchPaths () 2189 { 2190 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 2191 if (properties_sp) 2192 return properties_sp->GetDebugFileSearchPaths(); 2193 return FileSpecList(); 2194 } 2195 2196 FileSpecList 2197 Target::GetDefaultClangModuleSearchPaths () 2198 { 2199 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 2200 if (properties_sp) 2201 return properties_sp->GetClangModuleSearchPaths(); 2202 return FileSpecList(); 2203 } 2204 2205 ArchSpec 2206 Target::GetDefaultArchitecture () 2207 { 2208 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 2209 if (properties_sp) 2210 return properties_sp->GetDefaultArchitecture(); 2211 return ArchSpec(); 2212 } 2213 2214 void 2215 Target::SetDefaultArchitecture (const ArchSpec &arch) 2216 { 2217 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 2218 if (properties_sp) 2219 { 2220 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str()); 2221 return properties_sp->SetDefaultArchitecture(arch); 2222 } 2223 } 2224 2225 Target * 2226 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) 2227 { 2228 // The target can either exist in the "process" of ExecutionContext, or in 2229 // the "target_sp" member of SymbolContext. This accessor helper function 2230 // will get the target from one of these locations. 2231 2232 Target *target = nullptr; 2233 if (sc_ptr != nullptr) 2234 target = sc_ptr->target_sp.get(); 2235 if (target == nullptr && exe_ctx_ptr) 2236 target = exe_ctx_ptr->GetTargetPtr(); 2237 return target; 2238 } 2239 2240 ExpressionResults 2241 Target::EvaluateExpression(const char *expr_cstr, 2242 ExecutionContextScope *exe_scope, 2243 lldb::ValueObjectSP &result_valobj_sp, 2244 const EvaluateExpressionOptions& options, 2245 std::string *fixed_expression) 2246 { 2247 result_valobj_sp.reset(); 2248 2249 ExpressionResults execution_results = eExpressionSetupError; 2250 2251 if (expr_cstr == nullptr || expr_cstr[0] == '\0') 2252 return execution_results; 2253 2254 // We shouldn't run stop hooks in expressions. 2255 // Be sure to reset this if you return anywhere within this function. 2256 bool old_suppress_value = m_suppress_stop_hooks; 2257 m_suppress_stop_hooks = true; 2258 2259 ExecutionContext exe_ctx; 2260 2261 if (exe_scope) 2262 { 2263 exe_scope->CalculateExecutionContext(exe_ctx); 2264 } 2265 else if (m_process_sp) 2266 { 2267 m_process_sp->CalculateExecutionContext(exe_ctx); 2268 } 2269 else 2270 { 2271 CalculateExecutionContext(exe_ctx); 2272 } 2273 2274 // Make sure we aren't just trying to see the value of a persistent 2275 // variable (something like "$0") 2276 lldb::ExpressionVariableSP persistent_var_sp; 2277 // Only check for persistent variables the expression starts with a '$' 2278 if (expr_cstr[0] == '$') 2279 persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC)->GetPersistentExpressionState()->GetVariable (expr_cstr); 2280 2281 if (persistent_var_sp) 2282 { 2283 result_valobj_sp = persistent_var_sp->GetValueObject (); 2284 execution_results = eExpressionCompleted; 2285 } 2286 else 2287 { 2288 const char *prefix = GetExpressionPrefixContentsAsCString(); 2289 Error error; 2290 execution_results = UserExpression::Evaluate (exe_ctx, 2291 options, 2292 expr_cstr, 2293 prefix, 2294 result_valobj_sp, 2295 error, 2296 0, // Line Number 2297 fixed_expression); 2298 } 2299 2300 m_suppress_stop_hooks = old_suppress_value; 2301 2302 return execution_results; 2303 } 2304 2305 lldb::ExpressionVariableSP 2306 Target::GetPersistentVariable(const ConstString &name) 2307 { 2308 lldb::ExpressionVariableSP variable_sp; 2309 m_scratch_type_system_map.ForEach([this, name, &variable_sp](TypeSystem *type_system) -> bool 2310 { 2311 if (PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState()) 2312 { 2313 variable_sp = persistent_state->GetVariable(name); 2314 2315 if (variable_sp) 2316 return false; // Stop iterating the ForEach 2317 } 2318 return true; // Keep iterating the ForEach 2319 }); 2320 return variable_sp; 2321 } 2322 2323 lldb::addr_t 2324 Target::GetPersistentSymbol(const ConstString &name) 2325 { 2326 lldb::addr_t address = LLDB_INVALID_ADDRESS; 2327 2328 m_scratch_type_system_map.ForEach([this, name, &address](TypeSystem *type_system) -> bool 2329 { 2330 if (PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState()) 2331 { 2332 address = persistent_state->LookupSymbol(name); 2333 if (address != LLDB_INVALID_ADDRESS) 2334 return false; // Stop iterating the ForEach 2335 } 2336 return true; // Keep iterating the ForEach 2337 }); 2338 return address; 2339 } 2340 2341 lldb::addr_t 2342 Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 2343 { 2344 addr_t code_addr = load_addr; 2345 switch (m_arch.GetMachine()) 2346 { 2347 case llvm::Triple::mips: 2348 case llvm::Triple::mipsel: 2349 case llvm::Triple::mips64: 2350 case llvm::Triple::mips64el: 2351 switch (addr_class) 2352 { 2353 case eAddressClassData: 2354 case eAddressClassDebug: 2355 return LLDB_INVALID_ADDRESS; 2356 2357 case eAddressClassUnknown: 2358 case eAddressClassInvalid: 2359 case eAddressClassCode: 2360 case eAddressClassCodeAlternateISA: 2361 case eAddressClassRuntime: 2362 if ((code_addr & 2ull) || (addr_class == eAddressClassCodeAlternateISA)) 2363 code_addr |= 1ull; 2364 break; 2365 } 2366 break; 2367 2368 case llvm::Triple::arm: 2369 case llvm::Triple::thumb: 2370 switch (addr_class) 2371 { 2372 case eAddressClassData: 2373 case eAddressClassDebug: 2374 return LLDB_INVALID_ADDRESS; 2375 2376 case eAddressClassUnknown: 2377 case eAddressClassInvalid: 2378 case eAddressClassCode: 2379 case eAddressClassCodeAlternateISA: 2380 case eAddressClassRuntime: 2381 // Check if bit zero it no set? 2382 if ((code_addr & 1ull) == 0) 2383 { 2384 // Bit zero isn't set, check if the address is a multiple of 2? 2385 if (code_addr & 2ull) 2386 { 2387 // The address is a multiple of 2 so it must be thumb, set bit zero 2388 code_addr |= 1ull; 2389 } 2390 else if (addr_class == eAddressClassCodeAlternateISA) 2391 { 2392 // We checked the address and the address claims to be the alternate ISA 2393 // which means thumb, so set bit zero. 2394 code_addr |= 1ull; 2395 } 2396 } 2397 break; 2398 } 2399 break; 2400 2401 default: 2402 break; 2403 } 2404 return code_addr; 2405 } 2406 2407 lldb::addr_t 2408 Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 2409 { 2410 addr_t opcode_addr = load_addr; 2411 switch (m_arch.GetMachine()) 2412 { 2413 case llvm::Triple::mips: 2414 case llvm::Triple::mipsel: 2415 case llvm::Triple::mips64: 2416 case llvm::Triple::mips64el: 2417 case llvm::Triple::arm: 2418 case llvm::Triple::thumb: 2419 switch (addr_class) 2420 { 2421 case eAddressClassData: 2422 case eAddressClassDebug: 2423 return LLDB_INVALID_ADDRESS; 2424 2425 case eAddressClassInvalid: 2426 case eAddressClassUnknown: 2427 case eAddressClassCode: 2428 case eAddressClassCodeAlternateISA: 2429 case eAddressClassRuntime: 2430 opcode_addr &= ~(1ull); 2431 break; 2432 } 2433 break; 2434 2435 default: 2436 break; 2437 } 2438 return opcode_addr; 2439 } 2440 2441 lldb::addr_t 2442 Target::GetBreakableLoadAddress (lldb::addr_t addr) 2443 { 2444 addr_t breakable_addr = addr; 2445 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 2446 2447 switch (m_arch.GetMachine()) 2448 { 2449 default: 2450 break; 2451 case llvm::Triple::mips: 2452 case llvm::Triple::mipsel: 2453 case llvm::Triple::mips64: 2454 case llvm::Triple::mips64el: 2455 { 2456 addr_t function_start = 0; 2457 addr_t current_offset = 0; 2458 uint32_t loop_count = 0; 2459 Address resolved_addr; 2460 uint32_t arch_flags = m_arch.GetFlags (); 2461 bool IsMips16 = arch_flags & ArchSpec::eMIPSAse_mips16; 2462 bool IsMicromips = arch_flags & ArchSpec::eMIPSAse_micromips; 2463 SectionLoadList §ion_load_list = GetSectionLoadList(); 2464 2465 if (section_load_list.IsEmpty()) 2466 // No sections are loaded, so we must assume we are not running yet 2467 // and need to operate only on file address. 2468 m_images.ResolveFileAddress (addr, resolved_addr); 2469 else 2470 section_load_list.ResolveLoadAddress(addr, resolved_addr); 2471 2472 // Get the function boundaries to make sure we don't scan back before the beginning of the current function. 2473 ModuleSP temp_addr_module_sp (resolved_addr.GetModule()); 2474 if (temp_addr_module_sp) 2475 { 2476 SymbolContext sc; 2477 uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol; 2478 temp_addr_module_sp->ResolveSymbolContextForAddress(resolved_addr, resolve_scope, sc); 2479 Address sym_addr; 2480 if (sc.function) 2481 sym_addr = sc.function->GetAddressRange().GetBaseAddress(); 2482 else if (sc.symbol) 2483 sym_addr = sc.symbol->GetAddress(); 2484 2485 function_start = sym_addr.GetLoadAddress(this); 2486 if (function_start == LLDB_INVALID_ADDRESS) 2487 function_start = sym_addr.GetFileAddress(); 2488 2489 if (function_start) 2490 current_offset = addr - function_start; 2491 } 2492 2493 // If breakpoint address is start of function then we dont have to do anything. 2494 if (current_offset == 0) 2495 return breakable_addr; 2496 else 2497 loop_count = current_offset / 2; 2498 2499 if (loop_count > 3) 2500 { 2501 // Scan previous 6 bytes 2502 if (IsMips16 | IsMicromips) 2503 loop_count = 3; 2504 // For mips-only, instructions are always 4 bytes, so scan previous 4 bytes only. 2505 else 2506 loop_count = 2; 2507 } 2508 2509 // Create Disassembler Instance 2510 lldb::DisassemblerSP disasm_sp(Disassembler::FindPlugin(m_arch, nullptr, nullptr)); 2511 2512 ExecutionContext exe_ctx; 2513 CalculateExecutionContext(exe_ctx); 2514 InstructionList instruction_list; 2515 InstructionSP prev_insn; 2516 bool prefer_file_cache = true; // Read from file 2517 uint32_t inst_to_choose = 0; 2518 2519 for (uint32_t i = 1; i <= loop_count; i++) 2520 { 2521 // Adjust the address to read from. 2522 resolved_addr.Slide (-2); 2523 AddressRange range(resolved_addr, i*2); 2524 uint32_t insn_size = 0; 2525 2526 disasm_sp->ParseInstructions(&exe_ctx, range, nullptr, prefer_file_cache); 2527 2528 uint32_t num_insns = disasm_sp->GetInstructionList().GetSize(); 2529 if (num_insns) 2530 { 2531 prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0); 2532 insn_size = prev_insn->GetOpcode().GetByteSize(); 2533 if (i == 1 && insn_size == 2) 2534 { 2535 // This looks like a valid 2-byte instruction (but it could be a part of upper 4 byte instruction). 2536 instruction_list.Append(prev_insn); 2537 inst_to_choose = 1; 2538 } 2539 else if (i == 2) 2540 { 2541 // Here we may get one 4-byte instruction or two 2-byte instructions. 2542 if (num_insns == 2) 2543 { 2544 // Looks like there are two 2-byte instructions above our breakpoint target address. 2545 // Now the upper 2-byte instruction is either a valid 2-byte instruction or could be a part of it's upper 4-byte instruction. 2546 // In both cases we don't care because in this case lower 2-byte instruction is definitely a valid instruction 2547 // and whatever i=1 iteration has found out is true. 2548 inst_to_choose = 1; 2549 break; 2550 } 2551 else if (insn_size == 4) 2552 { 2553 // This instruction claims its a valid 4-byte instruction. But it could be a part of it's upper 4-byte instruction. 2554 // Lets try scanning upper 2 bytes to verify this. 2555 instruction_list.Append(prev_insn); 2556 inst_to_choose = 2; 2557 } 2558 } 2559 else if (i == 3) 2560 { 2561 if (insn_size == 4) 2562 // FIXME: We reached here that means instruction at [target - 4] has already claimed to be a 4-byte instruction, 2563 // and now instruction at [target - 6] is also claiming that it's a 4-byte instruction. This can not be true. 2564 // In this case we can not decide the valid previous instruction so we let lldb set the breakpoint at the address given by user. 2565 inst_to_choose = 0; 2566 else 2567 // This is straight-forward 2568 inst_to_choose = 2; 2569 break; 2570 } 2571 } 2572 else 2573 { 2574 // Decode failed, bytes do not form a valid instruction. So whatever previous iteration has found out is true. 2575 if (i > 1) 2576 { 2577 inst_to_choose = i - 1; 2578 break; 2579 } 2580 } 2581 } 2582 2583 // Check if we are able to find any valid instruction. 2584 if (inst_to_choose) 2585 { 2586 if (inst_to_choose > instruction_list.GetSize()) 2587 inst_to_choose--; 2588 prev_insn = instruction_list.GetInstructionAtIndex(inst_to_choose - 1); 2589 2590 if (prev_insn->HasDelaySlot()) 2591 { 2592 uint32_t shift_size = prev_insn->GetOpcode().GetByteSize(); 2593 // Adjust the breakable address 2594 breakable_addr = addr - shift_size; 2595 if (log) 2596 log->Printf ("Target::%s Breakpoint at 0x%8.8" PRIx64 " is adjusted to 0x%8.8" PRIx64 " due to delay slot\n", __FUNCTION__, addr, breakable_addr); 2597 } 2598 } 2599 break; 2600 } 2601 } 2602 return breakable_addr; 2603 } 2604 2605 SourceManager & 2606 Target::GetSourceManager () 2607 { 2608 if (!m_source_manager_ap) 2609 m_source_manager_ap.reset (new SourceManager(shared_from_this())); 2610 return *m_source_manager_ap; 2611 } 2612 2613 ClangModulesDeclVendor * 2614 Target::GetClangModulesDeclVendor () 2615 { 2616 static std::mutex s_clang_modules_decl_vendor_mutex; // If this is contended we can make it per-target 2617 2618 { 2619 std::lock_guard<std::mutex> guard(s_clang_modules_decl_vendor_mutex); 2620 2621 if (!m_clang_modules_decl_vendor_ap) 2622 { 2623 m_clang_modules_decl_vendor_ap.reset(ClangModulesDeclVendor::Create(*this)); 2624 } 2625 } 2626 2627 return m_clang_modules_decl_vendor_ap.get(); 2628 } 2629 2630 Target::StopHookSP 2631 Target::CreateStopHook () 2632 { 2633 lldb::user_id_t new_uid = ++m_stop_hook_next_id; 2634 Target::StopHookSP stop_hook_sp (new StopHook(shared_from_this(), new_uid)); 2635 m_stop_hooks[new_uid] = stop_hook_sp; 2636 return stop_hook_sp; 2637 } 2638 2639 bool 2640 Target::RemoveStopHookByID (lldb::user_id_t user_id) 2641 { 2642 size_t num_removed = m_stop_hooks.erase(user_id); 2643 return (num_removed != 0); 2644 } 2645 2646 void 2647 Target::RemoveAllStopHooks () 2648 { 2649 m_stop_hooks.clear(); 2650 } 2651 2652 Target::StopHookSP 2653 Target::GetStopHookByID (lldb::user_id_t user_id) 2654 { 2655 StopHookSP found_hook; 2656 2657 StopHookCollection::iterator specified_hook_iter; 2658 specified_hook_iter = m_stop_hooks.find (user_id); 2659 if (specified_hook_iter != m_stop_hooks.end()) 2660 found_hook = (*specified_hook_iter).second; 2661 return found_hook; 2662 } 2663 2664 bool 2665 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state) 2666 { 2667 StopHookCollection::iterator specified_hook_iter; 2668 specified_hook_iter = m_stop_hooks.find (user_id); 2669 if (specified_hook_iter == m_stop_hooks.end()) 2670 return false; 2671 2672 (*specified_hook_iter).second->SetIsActive (active_state); 2673 return true; 2674 } 2675 2676 void 2677 Target::SetAllStopHooksActiveState (bool active_state) 2678 { 2679 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 2680 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2681 { 2682 (*pos).second->SetIsActive (active_state); 2683 } 2684 } 2685 2686 void 2687 Target::RunStopHooks () 2688 { 2689 if (m_suppress_stop_hooks) 2690 return; 2691 2692 if (!m_process_sp) 2693 return; 2694 2695 // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression 2696 // since in that case we do not want to run the stop-hooks 2697 if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression()) 2698 return; 2699 2700 if (m_stop_hooks.empty()) 2701 return; 2702 2703 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 2704 2705 // If there aren't any active stop hooks, don't bother either: 2706 bool any_active_hooks = false; 2707 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2708 { 2709 if ((*pos).second->IsActive()) 2710 { 2711 any_active_hooks = true; 2712 break; 2713 } 2714 } 2715 if (!any_active_hooks) 2716 return; 2717 2718 CommandReturnObject result; 2719 2720 std::vector<ExecutionContext> exc_ctx_with_reasons; 2721 std::vector<SymbolContext> sym_ctx_with_reasons; 2722 2723 ThreadList &cur_threadlist = m_process_sp->GetThreadList(); 2724 size_t num_threads = cur_threadlist.GetSize(); 2725 for (size_t i = 0; i < num_threads; i++) 2726 { 2727 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i); 2728 if (cur_thread_sp->ThreadStoppedForAReason()) 2729 { 2730 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0); 2731 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get())); 2732 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything)); 2733 } 2734 } 2735 2736 // If no threads stopped for a reason, don't run the stop-hooks. 2737 size_t num_exe_ctx = exc_ctx_with_reasons.size(); 2738 if (num_exe_ctx == 0) 2739 return; 2740 2741 result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream()); 2742 result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream()); 2743 2744 bool keep_going = true; 2745 bool hooks_ran = false; 2746 bool print_hook_header = (m_stop_hooks.size() != 1); 2747 bool print_thread_header = (num_exe_ctx != 1); 2748 2749 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) 2750 { 2751 // result.Clear(); 2752 StopHookSP cur_hook_sp = (*pos).second; 2753 if (!cur_hook_sp->IsActive()) 2754 continue; 2755 2756 bool any_thread_matched = false; 2757 for (size_t i = 0; keep_going && i < num_exe_ctx; i++) 2758 { 2759 if ((cur_hook_sp->GetSpecifier() == nullptr 2760 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i])) 2761 && (cur_hook_sp->GetThreadSpecifier() == nullptr 2762 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef()))) 2763 { 2764 if (!hooks_ran) 2765 { 2766 hooks_ran = true; 2767 } 2768 if (print_hook_header && !any_thread_matched) 2769 { 2770 const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ? 2771 cur_hook_sp->GetCommands().GetStringAtIndex(0) : 2772 nullptr); 2773 if (cmd) 2774 result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd); 2775 else 2776 result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID()); 2777 any_thread_matched = true; 2778 } 2779 2780 if (print_thread_header) 2781 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID()); 2782 2783 CommandInterpreterRunOptions options; 2784 options.SetStopOnContinue (true); 2785 options.SetStopOnError (true); 2786 options.SetEchoCommands (false); 2787 options.SetPrintResults (true); 2788 options.SetAddToHistory (false); 2789 2790 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(), 2791 &exc_ctx_with_reasons[i], 2792 options, 2793 result); 2794 2795 // If the command started the target going again, we should bag out of 2796 // running the stop hooks. 2797 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) || 2798 (result.GetStatus() == eReturnStatusSuccessContinuingResult)) 2799 { 2800 result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID()); 2801 keep_going = false; 2802 } 2803 } 2804 } 2805 } 2806 2807 result.GetImmediateOutputStream()->Flush(); 2808 result.GetImmediateErrorStream()->Flush(); 2809 } 2810 2811 const TargetPropertiesSP & 2812 Target::GetGlobalProperties() 2813 { 2814 // NOTE: intentional leak so we don't crash if global destructor chain gets 2815 // called as other threads still use the result of this function 2816 static TargetPropertiesSP *g_settings_sp_ptr = nullptr; 2817 static std::once_flag g_once_flag; 2818 std::call_once(g_once_flag, []() { 2819 g_settings_sp_ptr = new TargetPropertiesSP(new TargetProperties(nullptr)); 2820 }); 2821 return *g_settings_sp_ptr; 2822 } 2823 2824 Error 2825 Target::Install (ProcessLaunchInfo *launch_info) 2826 { 2827 Error error; 2828 PlatformSP platform_sp (GetPlatform()); 2829 if (platform_sp) 2830 { 2831 if (platform_sp->IsRemote()) 2832 { 2833 if (platform_sp->IsConnected()) 2834 { 2835 // Install all files that have an install path, and always install the 2836 // main executable when connected to a remote platform 2837 const ModuleList& modules = GetImages(); 2838 const size_t num_images = modules.GetSize(); 2839 for (size_t idx = 0; idx < num_images; ++idx) 2840 { 2841 ModuleSP module_sp(modules.GetModuleAtIndex(idx)); 2842 if (module_sp) 2843 { 2844 const bool is_main_executable = module_sp == GetExecutableModule(); 2845 FileSpec local_file (module_sp->GetFileSpec()); 2846 if (local_file) 2847 { 2848 FileSpec remote_file (module_sp->GetRemoteInstallFileSpec()); 2849 if (!remote_file) 2850 { 2851 if (is_main_executable) // TODO: add setting for always installing main executable??? 2852 { 2853 // Always install the main executable 2854 remote_file = platform_sp->GetRemoteWorkingDirectory(); 2855 remote_file.AppendPathComponent(module_sp->GetFileSpec().GetFilename().GetCString()); 2856 } 2857 } 2858 if (remote_file) 2859 { 2860 error = platform_sp->Install(local_file, remote_file); 2861 if (error.Success()) 2862 { 2863 module_sp->SetPlatformFileSpec(remote_file); 2864 if (is_main_executable) 2865 { 2866 platform_sp->SetFilePermissions(remote_file, 0700); 2867 if (launch_info) 2868 launch_info->SetExecutableFile(remote_file, false); 2869 } 2870 } 2871 else 2872 break; 2873 } 2874 } 2875 } 2876 } 2877 } 2878 } 2879 } 2880 return error; 2881 } 2882 2883 bool 2884 Target::ResolveLoadAddress (addr_t load_addr, Address &so_addr, uint32_t stop_id) 2885 { 2886 return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr); 2887 } 2888 2889 bool 2890 Target::ResolveFileAddress (lldb::addr_t file_addr, Address &resolved_addr) 2891 { 2892 return m_images.ResolveFileAddress(file_addr, resolved_addr); 2893 } 2894 2895 bool 2896 Target::SetSectionLoadAddress (const SectionSP §ion_sp, addr_t new_section_load_addr, bool warn_multiple) 2897 { 2898 const addr_t old_section_load_addr = m_section_load_history.GetSectionLoadAddress (SectionLoadHistory::eStopIDNow, section_sp); 2899 if (old_section_load_addr != new_section_load_addr) 2900 { 2901 uint32_t stop_id = 0; 2902 ProcessSP process_sp(GetProcessSP()); 2903 if (process_sp) 2904 stop_id = process_sp->GetStopID(); 2905 else 2906 stop_id = m_section_load_history.GetLastStopID(); 2907 if (m_section_load_history.SetSectionLoadAddress (stop_id, section_sp, new_section_load_addr, warn_multiple)) 2908 return true; // Return true if the section load address was changed... 2909 } 2910 return false; // Return false to indicate nothing changed 2911 } 2912 2913 size_t 2914 Target::UnloadModuleSections (const ModuleList &module_list) 2915 { 2916 size_t section_unload_count = 0; 2917 size_t num_modules = module_list.GetSize(); 2918 for (size_t i=0; i<num_modules; ++i) 2919 { 2920 section_unload_count += UnloadModuleSections (module_list.GetModuleAtIndex(i)); 2921 } 2922 return section_unload_count; 2923 } 2924 2925 size_t 2926 Target::UnloadModuleSections (const lldb::ModuleSP &module_sp) 2927 { 2928 uint32_t stop_id = 0; 2929 ProcessSP process_sp(GetProcessSP()); 2930 if (process_sp) 2931 stop_id = process_sp->GetStopID(); 2932 else 2933 stop_id = m_section_load_history.GetLastStopID(); 2934 SectionList *sections = module_sp->GetSectionList(); 2935 size_t section_unload_count = 0; 2936 if (sections) 2937 { 2938 const uint32_t num_sections = sections->GetNumSections(0); 2939 for (uint32_t i = 0; i < num_sections; ++i) 2940 { 2941 section_unload_count += m_section_load_history.SetSectionUnloaded(stop_id, sections->GetSectionAtIndex(i)); 2942 } 2943 } 2944 return section_unload_count; 2945 } 2946 2947 bool 2948 Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp) 2949 { 2950 uint32_t stop_id = 0; 2951 ProcessSP process_sp(GetProcessSP()); 2952 if (process_sp) 2953 stop_id = process_sp->GetStopID(); 2954 else 2955 stop_id = m_section_load_history.GetLastStopID(); 2956 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp); 2957 } 2958 2959 bool 2960 Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp, addr_t load_addr) 2961 { 2962 uint32_t stop_id = 0; 2963 ProcessSP process_sp(GetProcessSP()); 2964 if (process_sp) 2965 stop_id = process_sp->GetStopID(); 2966 else 2967 stop_id = m_section_load_history.GetLastStopID(); 2968 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp, load_addr); 2969 } 2970 2971 void 2972 Target::ClearAllLoadedSections () 2973 { 2974 m_section_load_history.Clear(); 2975 } 2976 2977 Error 2978 Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream) 2979 { 2980 Error error; 2981 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 2982 2983 if (log) 2984 log->Printf ("Target::%s() called for %s", __FUNCTION__, launch_info.GetExecutableFile().GetPath().c_str ()); 2985 2986 StateType state = eStateInvalid; 2987 2988 // Scope to temporarily get the process state in case someone has manually 2989 // remotely connected already to a process and we can skip the platform 2990 // launching. 2991 { 2992 ProcessSP process_sp (GetProcessSP()); 2993 2994 if (process_sp) 2995 { 2996 state = process_sp->GetState(); 2997 if (log) 2998 log->Printf ("Target::%s the process exists, and its current state is %s", __FUNCTION__, StateAsCString (state)); 2999 } 3000 else 3001 { 3002 if (log) 3003 log->Printf ("Target::%s the process instance doesn't currently exist.", __FUNCTION__); 3004 } 3005 } 3006 3007 launch_info.GetFlags().Set (eLaunchFlagDebug); 3008 3009 // Get the value of synchronous execution here. If you wait till after you have started to 3010 // run, then you could have hit a breakpoint, whose command might switch the value, and 3011 // then you'll pick up that incorrect value. 3012 Debugger &debugger = GetDebugger(); 3013 const bool synchronous_execution = debugger.GetCommandInterpreter().GetSynchronous (); 3014 3015 PlatformSP platform_sp (GetPlatform()); 3016 3017 // Finalize the file actions, and if none were given, default to opening 3018 // up a pseudo terminal 3019 const bool default_to_use_pty = platform_sp ? platform_sp->IsHost() : false; 3020 if (log) 3021 log->Printf ("Target::%s have platform=%s, platform_sp->IsHost()=%s, default_to_use_pty=%s", 3022 __FUNCTION__, 3023 platform_sp ? "true" : "false", 3024 platform_sp ? (platform_sp->IsHost () ? "true" : "false") : "n/a", 3025 default_to_use_pty ? "true" : "false"); 3026 3027 launch_info.FinalizeFileActions (this, default_to_use_pty); 3028 3029 if (state == eStateConnected) 3030 { 3031 if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY)) 3032 { 3033 error.SetErrorString("can't launch in tty when launching through a remote connection"); 3034 return error; 3035 } 3036 } 3037 3038 if (!launch_info.GetArchitecture().IsValid()) 3039 launch_info.GetArchitecture() = GetArchitecture(); 3040 3041 // If we're not already connected to the process, and if we have a platform that can launch a process for debugging, go ahead and do that here. 3042 if (state != eStateConnected && platform_sp && platform_sp->CanDebugProcess ()) 3043 { 3044 if (log) 3045 log->Printf ("Target::%s asking the platform to debug the process", __FUNCTION__); 3046 3047 // Get a weak pointer to the previous process if we have one 3048 ProcessWP process_wp; 3049 if (m_process_sp) 3050 process_wp = m_process_sp; 3051 m_process_sp = GetPlatform()->DebugProcess (launch_info, 3052 debugger, 3053 this, 3054 error); 3055 3056 // Cleanup the old process since someone might still have a strong 3057 // reference to this process and we would like to allow it to cleanup 3058 // as much as it can without the object being destroyed. We try to 3059 // lock the shared pointer and if that works, then someone else still 3060 // has a strong reference to the process. 3061 3062 ProcessSP old_process_sp(process_wp.lock()); 3063 if (old_process_sp) 3064 old_process_sp->Finalize(); 3065 } 3066 else 3067 { 3068 if (log) 3069 log->Printf ("Target::%s the platform doesn't know how to debug a process, getting a process plugin to do this for us.", __FUNCTION__); 3070 3071 if (state == eStateConnected) 3072 { 3073 assert(m_process_sp); 3074 } 3075 else 3076 { 3077 // Use a Process plugin to construct the process. 3078 const char *plugin_name = launch_info.GetProcessPluginName(); 3079 CreateProcess(launch_info.GetListenerForProcess(debugger), plugin_name, nullptr); 3080 } 3081 3082 // Since we didn't have a platform launch the process, launch it here. 3083 if (m_process_sp) 3084 error = m_process_sp->Launch (launch_info); 3085 } 3086 3087 if (!m_process_sp) 3088 { 3089 if (error.Success()) 3090 error.SetErrorString("failed to launch or debug process"); 3091 return error; 3092 } 3093 3094 if (error.Success()) 3095 { 3096 if (synchronous_execution || !launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) 3097 { 3098 ListenerSP hijack_listener_sp (launch_info.GetHijackListener()); 3099 if (!hijack_listener_sp) 3100 { 3101 hijack_listener_sp = Listener::MakeListener("lldb.Target.Launch.hijack"); 3102 launch_info.SetHijackListener(hijack_listener_sp); 3103 m_process_sp->HijackProcessEvents(hijack_listener_sp); 3104 } 3105 3106 StateType state = m_process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr, false, 3107 hijack_listener_sp, nullptr); 3108 3109 if (state == eStateStopped) 3110 { 3111 if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) 3112 { 3113 if (synchronous_execution) 3114 { 3115 error = m_process_sp->PrivateResume(); 3116 if (error.Success()) 3117 { 3118 state = m_process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr, true, 3119 hijack_listener_sp, stream); 3120 const bool must_be_alive = false; // eStateExited is ok, so this must be false 3121 if (!StateIsStoppedState(state, must_be_alive)) 3122 { 3123 error.SetErrorStringWithFormat("process isn't stopped: %s", StateAsCString(state)); 3124 } 3125 } 3126 } 3127 else 3128 { 3129 m_process_sp->RestoreProcessEvents(); 3130 error = m_process_sp->PrivateResume(); 3131 } 3132 if (!error.Success()) 3133 { 3134 Error error2; 3135 error2.SetErrorStringWithFormat("process resume at entry point failed: %s", error.AsCString()); 3136 error = error2; 3137 } 3138 } 3139 } 3140 else if (state == eStateExited) 3141 { 3142 bool with_shell = !!launch_info.GetShell(); 3143 const int exit_status = m_process_sp->GetExitStatus(); 3144 const char *exit_desc = m_process_sp->GetExitDescription(); 3145 #define LAUNCH_SHELL_MESSAGE "\n'r' and 'run' are aliases that default to launching through a shell.\nTry launching without going through a shell by using 'process launch'." 3146 if (exit_desc && exit_desc[0]) 3147 { 3148 if (with_shell) 3149 error.SetErrorStringWithFormat ("process exited with status %i (%s)" LAUNCH_SHELL_MESSAGE, exit_status, exit_desc); 3150 else 3151 error.SetErrorStringWithFormat ("process exited with status %i (%s)", exit_status, exit_desc); 3152 } 3153 else 3154 { 3155 if (with_shell) 3156 error.SetErrorStringWithFormat ("process exited with status %i" LAUNCH_SHELL_MESSAGE, exit_status); 3157 else 3158 error.SetErrorStringWithFormat ("process exited with status %i", exit_status); 3159 } 3160 } 3161 else 3162 { 3163 error.SetErrorStringWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state)); 3164 } 3165 } 3166 m_process_sp->RestoreProcessEvents (); 3167 } 3168 else 3169 { 3170 Error error2; 3171 error2.SetErrorStringWithFormat ("process launch failed: %s", error.AsCString()); 3172 error = error2; 3173 } 3174 return error; 3175 } 3176 3177 Error 3178 Target::Attach (ProcessAttachInfo &attach_info, Stream *stream) 3179 { 3180 auto state = eStateInvalid; 3181 auto process_sp = GetProcessSP (); 3182 if (process_sp) 3183 { 3184 state = process_sp->GetState (); 3185 if (process_sp->IsAlive () && state != eStateConnected) 3186 { 3187 if (state == eStateAttaching) 3188 return Error ("process attach is in progress"); 3189 return Error ("a process is already being debugged"); 3190 } 3191 } 3192 3193 const ModuleSP old_exec_module_sp = GetExecutableModule (); 3194 3195 // If no process info was specified, then use the target executable 3196 // name as the process to attach to by default 3197 if (!attach_info.ProcessInfoSpecified ()) 3198 { 3199 if (old_exec_module_sp) 3200 attach_info.GetExecutableFile ().GetFilename () = old_exec_module_sp->GetPlatformFileSpec ().GetFilename (); 3201 3202 if (!attach_info.ProcessInfoSpecified ()) 3203 { 3204 return Error ("no process specified, create a target with a file, or specify the --pid or --name"); 3205 } 3206 } 3207 3208 const auto platform_sp = GetDebugger ().GetPlatformList ().GetSelectedPlatform (); 3209 ListenerSP hijack_listener_sp; 3210 const bool async = attach_info.GetAsync(); 3211 if (!async) 3212 { 3213 hijack_listener_sp = Listener::MakeListener("lldb.Target.Attach.attach.hijack"); 3214 attach_info.SetHijackListener (hijack_listener_sp); 3215 } 3216 3217 Error error; 3218 if (state != eStateConnected && platform_sp != nullptr && platform_sp->CanDebugProcess ()) 3219 { 3220 SetPlatform (platform_sp); 3221 process_sp = platform_sp->Attach (attach_info, GetDebugger (), this, error); 3222 } 3223 else 3224 { 3225 if (state != eStateConnected) 3226 { 3227 const char *plugin_name = attach_info.GetProcessPluginName (); 3228 process_sp = CreateProcess (attach_info.GetListenerForProcess (GetDebugger ()), plugin_name, nullptr); 3229 if (process_sp == nullptr) 3230 { 3231 error.SetErrorStringWithFormat ("failed to create process using plugin %s", (plugin_name) ? plugin_name : "null"); 3232 return error; 3233 } 3234 } 3235 if (hijack_listener_sp) 3236 process_sp->HijackProcessEvents (hijack_listener_sp); 3237 error = process_sp->Attach (attach_info); 3238 } 3239 3240 if (error.Success () && process_sp) 3241 { 3242 if (async) 3243 { 3244 process_sp->RestoreProcessEvents (); 3245 } 3246 else 3247 { 3248 state = process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr, false, 3249 attach_info.GetHijackListener(), stream); 3250 process_sp->RestoreProcessEvents (); 3251 3252 if (state != eStateStopped) 3253 { 3254 const char *exit_desc = process_sp->GetExitDescription (); 3255 if (exit_desc) 3256 error.SetErrorStringWithFormat ("%s", exit_desc); 3257 else 3258 error.SetErrorString ("process did not stop (no such process or permission problem?)"); 3259 process_sp->Destroy (false); 3260 } 3261 } 3262 } 3263 return error; 3264 } 3265 3266 //-------------------------------------------------------------- 3267 // Target::StopHook 3268 //-------------------------------------------------------------- 3269 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : 3270 UserID (uid), 3271 m_target_sp (target_sp), 3272 m_commands (), 3273 m_specifier_sp (), 3274 m_thread_spec_ap(), 3275 m_active (true) 3276 { 3277 } 3278 3279 Target::StopHook::StopHook (const StopHook &rhs) : 3280 UserID (rhs.GetID()), 3281 m_target_sp (rhs.m_target_sp), 3282 m_commands (rhs.m_commands), 3283 m_specifier_sp (rhs.m_specifier_sp), 3284 m_thread_spec_ap (), 3285 m_active (rhs.m_active) 3286 { 3287 if (rhs.m_thread_spec_ap) 3288 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); 3289 } 3290 3291 Target::StopHook::~StopHook() = default; 3292 3293 void 3294 Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier) 3295 { 3296 m_specifier_sp.reset(specifier); 3297 } 3298 3299 void 3300 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) 3301 { 3302 m_thread_spec_ap.reset (specifier); 3303 } 3304 3305 void 3306 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const 3307 { 3308 int indent_level = s->GetIndentLevel(); 3309 3310 s->SetIndentLevel(indent_level + 2); 3311 3312 s->Printf ("Hook: %" PRIu64 "\n", GetID()); 3313 if (m_active) 3314 s->Indent ("State: enabled\n"); 3315 else 3316 s->Indent ("State: disabled\n"); 3317 3318 if (m_specifier_sp) 3319 { 3320 s->Indent(); 3321 s->PutCString ("Specifier:\n"); 3322 s->SetIndentLevel (indent_level + 4); 3323 m_specifier_sp->GetDescription (s, level); 3324 s->SetIndentLevel (indent_level + 2); 3325 } 3326 3327 if (m_thread_spec_ap) 3328 { 3329 StreamString tmp; 3330 s->Indent("Thread:\n"); 3331 m_thread_spec_ap->GetDescription (&tmp, level); 3332 s->SetIndentLevel (indent_level + 4); 3333 s->Indent (tmp.GetData()); 3334 s->PutCString ("\n"); 3335 s->SetIndentLevel (indent_level + 2); 3336 } 3337 3338 s->Indent ("Commands: \n"); 3339 s->SetIndentLevel (indent_level + 4); 3340 uint32_t num_commands = m_commands.GetSize(); 3341 for (uint32_t i = 0; i < num_commands; i++) 3342 { 3343 s->Indent(m_commands.GetStringAtIndex(i)); 3344 s->PutCString ("\n"); 3345 } 3346 s->SetIndentLevel (indent_level); 3347 } 3348 3349 //-------------------------------------------------------------- 3350 // class TargetProperties 3351 //-------------------------------------------------------------- 3352 3353 OptionEnumValueElement 3354 lldb_private::g_dynamic_value_types[] = 3355 { 3356 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"}, 3357 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."}, 3358 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."}, 3359 { 0, nullptr, nullptr } 3360 }; 3361 3362 static OptionEnumValueElement 3363 g_inline_breakpoint_enums[] = 3364 { 3365 { 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."}, 3366 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."}, 3367 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."}, 3368 { 0, nullptr, nullptr } 3369 }; 3370 3371 typedef enum x86DisassemblyFlavor 3372 { 3373 eX86DisFlavorDefault, 3374 eX86DisFlavorIntel, 3375 eX86DisFlavorATT 3376 } x86DisassemblyFlavor; 3377 3378 static OptionEnumValueElement 3379 g_x86_dis_flavor_value_types[] = 3380 { 3381 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."}, 3382 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."}, 3383 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."}, 3384 { 0, nullptr, nullptr } 3385 }; 3386 3387 static OptionEnumValueElement 3388 g_hex_immediate_style_values[] = 3389 { 3390 { Disassembler::eHexStyleC, "c", "C-style (0xffff)."}, 3391 { Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."}, 3392 { 0, nullptr, nullptr } 3393 }; 3394 3395 static OptionEnumValueElement 3396 g_load_script_from_sym_file_values[] = 3397 { 3398 { eLoadScriptFromSymFileTrue, "true", "Load debug scripts inside symbol files"}, 3399 { eLoadScriptFromSymFileFalse, "false", "Do not load debug scripts inside symbol files."}, 3400 { eLoadScriptFromSymFileWarn, "warn", "Warn about debug scripts inside symbol files but do not load them."}, 3401 { 0, nullptr, nullptr } 3402 }; 3403 3404 static OptionEnumValueElement 3405 g_load_current_working_dir_lldbinit_values[] = 3406 { 3407 { eLoadCWDlldbinitTrue, "true", "Load .lldbinit files from current directory"}, 3408 { eLoadCWDlldbinitFalse, "false", "Do not load .lldbinit files from current directory"}, 3409 { eLoadCWDlldbinitWarn, "warn", "Warn about loading .lldbinit files from current directory"}, 3410 { 0, nullptr, nullptr } 3411 }; 3412 3413 static OptionEnumValueElement 3414 g_memory_module_load_level_values[] = 3415 { 3416 { eMemoryModuleLoadLevelMinimal, "minimal" , "Load minimal information when loading modules from memory. Currently this setting loads sections only."}, 3417 { eMemoryModuleLoadLevelPartial, "partial" , "Load partial information when loading modules from memory. Currently this setting loads sections and function bounds."}, 3418 { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."}, 3419 { 0, nullptr, nullptr } 3420 }; 3421 3422 static PropertyDefinition 3423 g_properties[] = 3424 { 3425 { "default-arch" , OptionValue::eTypeArch , true , 0 , nullptr, nullptr, "Default architecture to choose, when there's a choice." }, 3426 { "move-to-nearest-code" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Move breakpoints to nearest code." }, 3427 { "language" , OptionValue::eTypeLanguage , false, eLanguageTypeUnknown , nullptr, nullptr, "The language to use when interpreting expressions entered in commands." }, 3428 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "Path to a file containing expressions to be prepended to all expressions." }, 3429 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eDynamicDontRunTarget , nullptr, g_dynamic_value_types, "Should printed values be shown as their dynamic value." }, 3430 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Should synthetic values be used by default whenever available." }, 3431 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Skip function prologues when setting breakpoints by name." }, 3432 { "source-map" , OptionValue::eTypePathMap , false, 0 , nullptr, nullptr, "Source path remappings are used to track the change of location between a source file when built, and " 3433 "where it exists on the current system. It consists of an array of duples, the first element of each duple is " 3434 "some part (starting at the root) of the path to the file when it was built, " 3435 "and the second is where the remainder of the original build hierarchy is rooted on the local system. " 3436 "Each element of the array is checked in order and the first one that results in a match wins." }, 3437 { "exec-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "Executable search paths to use when locating executable files whose paths don't match the local file system." }, 3438 { "debug-file-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "List of directories to be searched when locating debug symbol files." }, 3439 { "clang-module-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "List of directories to be searched when locating modules for Clang." }, 3440 { "auto-import-clang-modules" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Automatically load Clang modules referred to by the program." }, 3441 { "auto-apply-fixits" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Automatically apply fix-it hints to expressions." }, 3442 { "notify-about-fixits" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Print the fixed expression text." }, 3443 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , nullptr, nullptr, "Maximum number of children to expand in any level of depth." }, 3444 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , nullptr, nullptr, "Maximum number of characters to show when using %s in summary strings." }, 3445 { "max-memory-read-size" , OptionValue::eTypeSInt64 , false, 1024 , nullptr, nullptr, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." }, 3446 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Consult the platform module avoid list when setting non-module specific breakpoints." }, 3447 { "arg0" , OptionValue::eTypeString , false, 0 , nullptr, nullptr, "The first argument passed to the program in the argument array which can be different from the executable itself." }, 3448 { "run-args" , OptionValue::eTypeArgs , false, 0 , nullptr, nullptr, "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." }, 3449 { "env-vars" , OptionValue::eTypeDictionary, false, OptionValue::eTypeString , nullptr, nullptr, "A list of all the environment variables to be passed to the executable's environment, and their values." }, 3450 { "inherit-env" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Inherit the environment from the process that is running LLDB." }, 3451 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for reading its standard input." }, 3452 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard output." }, 3453 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard error." }, 3454 { "detach-on-error" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "debugserver will detach (rather than killing) a process if it loses connection with lldb." }, 3455 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Disable Address Space Layout Randomization (ASLR)" }, 3456 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , nullptr, nullptr, "Disable stdin/stdout for process (e.g. for a GUI application)" }, 3457 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsAlways , nullptr, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. " 3458 "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. " 3459 "Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. " 3460 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. " 3461 "Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers " 3462 "and find that setting breakpoints is slow, then you can change this setting to headers. " 3463 "This setting allows you to control exactly which strategy is used when setting " 3464 "file and line breakpoints." }, 3465 // 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. 3466 { "x86-disassembly-flavor" , OptionValue::eTypeEnum , false, eX86DisFlavorDefault, nullptr, g_x86_dis_flavor_value_types, "The default disassembly flavor to use for x86 or x86-64 targets." }, 3467 { "use-hex-immediates" , OptionValue::eTypeBoolean , false, true, nullptr, nullptr, "Show immediates in disassembly as hexadecimal." }, 3468 { "hex-immediate-style" , OptionValue::eTypeEnum , false, Disassembler::eHexStyleC, nullptr, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." }, 3469 { "use-fast-stepping" , OptionValue::eTypeBoolean , false, true, nullptr, nullptr, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping." }, 3470 { "load-script-from-symbol-file" , OptionValue::eTypeEnum , false, eLoadScriptFromSymFileWarn, nullptr, g_load_script_from_sym_file_values, "Allow LLDB to load scripting resources embedded in symbol files when available." }, 3471 { "load-cwd-lldbinit" , OptionValue::eTypeEnum , false, eLoadCWDlldbinitWarn, nullptr, g_load_current_working_dir_lldbinit_values, "Allow LLDB to .lldbinit files from the current directory automatically." }, 3472 { "memory-module-load-level" , OptionValue::eTypeEnum , false, eMemoryModuleLoadLevelComplete, nullptr, g_memory_module_load_level_values, 3473 "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. " 3474 "This setting helps users control how much information gets loaded when loading modules from memory." 3475 "'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). " 3476 "'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). " 3477 "'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). " }, 3478 { "display-expression-in-crashlogs" , OptionValue::eTypeBoolean , false, false, nullptr, nullptr, "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." }, 3479 { "trap-handler-names" , OptionValue::eTypeArray , true, OptionValue::eTypeString, nullptr, nullptr, "A list of trap handler function names, e.g. a common Unix user process one is _sigtramp." }, 3480 { "display-runtime-support-values" , OptionValue::eTypeBoolean , false, false, nullptr, nullptr, "If true, LLDB will show variables that are meant to support the operation of a language's runtime support." }, 3481 { "non-stop-mode" , OptionValue::eTypeBoolean , false, 0, nullptr, nullptr, "Disable lock-step debugging, instead control threads independently." }, 3482 { nullptr , OptionValue::eTypeInvalid , false, 0 , nullptr, nullptr, nullptr } 3483 }; 3484 3485 enum 3486 { 3487 ePropertyDefaultArch, 3488 ePropertyMoveToNearestCode, 3489 ePropertyLanguage, 3490 ePropertyExprPrefix, 3491 ePropertyPreferDynamic, 3492 ePropertyEnableSynthetic, 3493 ePropertySkipPrologue, 3494 ePropertySourceMap, 3495 ePropertyExecutableSearchPaths, 3496 ePropertyDebugFileSearchPaths, 3497 ePropertyClangModuleSearchPaths, 3498 ePropertyAutoImportClangModules, 3499 ePropertyAutoApplyFixIts, 3500 ePropertyNotifyAboutFixIts, 3501 ePropertyMaxChildrenCount, 3502 ePropertyMaxSummaryLength, 3503 ePropertyMaxMemReadSize, 3504 ePropertyBreakpointUseAvoidList, 3505 ePropertyArg0, 3506 ePropertyRunArgs, 3507 ePropertyEnvVars, 3508 ePropertyInheritEnv, 3509 ePropertyInputPath, 3510 ePropertyOutputPath, 3511 ePropertyErrorPath, 3512 ePropertyDetachOnError, 3513 ePropertyDisableASLR, 3514 ePropertyDisableSTDIO, 3515 ePropertyInlineStrategy, 3516 ePropertyDisassemblyFlavor, 3517 ePropertyUseHexImmediates, 3518 ePropertyHexImmediateStyle, 3519 ePropertyUseFastStepping, 3520 ePropertyLoadScriptFromSymbolFile, 3521 ePropertyLoadCWDlldbinitFile, 3522 ePropertyMemoryModuleLoadLevel, 3523 ePropertyDisplayExpressionsInCrashlogs, 3524 ePropertyTrapHandlerNames, 3525 ePropertyDisplayRuntimeSupportValues, 3526 ePropertyNonStopModeEnabled, 3527 ePropertyExperimental 3528 }; 3529 3530 class TargetOptionValueProperties : public OptionValueProperties 3531 { 3532 public: 3533 TargetOptionValueProperties (const ConstString &name) : 3534 OptionValueProperties (name), 3535 m_target(nullptr), 3536 m_got_host_env (false) 3537 { 3538 } 3539 3540 // This constructor is used when creating TargetOptionValueProperties when it 3541 // is part of a new lldb_private::Target instance. It will copy all current 3542 // global property values as needed 3543 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) : 3544 OptionValueProperties(*target_properties_sp->GetValueProperties()), 3545 m_target (target), 3546 m_got_host_env (false) 3547 { 3548 } 3549 3550 const Property * 3551 GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override 3552 { 3553 // When getting the value for a key from the target options, we will always 3554 // try and grab the setting from the current target if there is one. Else we just 3555 // use the one from this instance. 3556 if (idx == ePropertyEnvVars) 3557 GetHostEnvironmentIfNeeded (); 3558 3559 if (exe_ctx) 3560 { 3561 Target *target = exe_ctx->GetTargetPtr(); 3562 if (target) 3563 { 3564 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get()); 3565 if (this != target_properties) 3566 return target_properties->ProtectedGetPropertyAtIndex (idx); 3567 } 3568 } 3569 return ProtectedGetPropertyAtIndex (idx); 3570 } 3571 3572 lldb::TargetSP 3573 GetTargetSP () 3574 { 3575 return m_target->shared_from_this(); 3576 } 3577 3578 protected: 3579 void 3580 GetHostEnvironmentIfNeeded () const 3581 { 3582 if (!m_got_host_env) 3583 { 3584 if (m_target) 3585 { 3586 m_got_host_env = true; 3587 const uint32_t idx = ePropertyInheritEnv; 3588 if (GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0)) 3589 { 3590 PlatformSP platform_sp (m_target->GetPlatform()); 3591 if (platform_sp) 3592 { 3593 StringList env; 3594 if (platform_sp->GetEnvironment(env)) 3595 { 3596 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary(nullptr, ePropertyEnvVars); 3597 if (env_dict) 3598 { 3599 const bool can_replace = false; 3600 const size_t envc = env.GetSize(); 3601 for (size_t idx=0; idx<envc; idx++) 3602 { 3603 const char *env_entry = env.GetStringAtIndex (idx); 3604 if (env_entry) 3605 { 3606 const char *equal_pos = ::strchr(env_entry, '='); 3607 ConstString key; 3608 // It is ok to have environment variables with no values 3609 const char *value = nullptr; 3610 if (equal_pos) 3611 { 3612 key.SetCStringWithLength(env_entry, equal_pos - env_entry); 3613 if (equal_pos[1]) 3614 value = equal_pos + 1; 3615 } 3616 else 3617 { 3618 key.SetCString(env_entry); 3619 } 3620 // Don't allow existing keys to be replaced with ones we get from the platform environment 3621 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace); 3622 } 3623 } 3624 } 3625 } 3626 } 3627 } 3628 } 3629 } 3630 } 3631 Target *m_target; 3632 mutable bool m_got_host_env; 3633 }; 3634 3635 //---------------------------------------------------------------------- 3636 // TargetProperties 3637 //---------------------------------------------------------------------- 3638 static PropertyDefinition 3639 g_experimental_properties[] 3640 { 3641 { "inject-local-vars", OptionValue::eTypeBoolean , true, true, nullptr, nullptr, "If true, inject local variables explicitly into the expression text. " 3642 "This will fix symbol resolution when there are name collisions between ivars and local variables. " 3643 "But it can make expressions run much more slowly." }, 3644 { nullptr, OptionValue::eTypeInvalid , true, 0 , nullptr, nullptr, nullptr } 3645 }; 3646 3647 enum 3648 { 3649 ePropertyInjectLocalVars = 0 3650 }; 3651 3652 class TargetExperimentalOptionValueProperties : public OptionValueProperties 3653 { 3654 public: 3655 TargetExperimentalOptionValueProperties () : 3656 OptionValueProperties (ConstString(Properties::GetExperimentalSettingsName())) 3657 { 3658 } 3659 }; 3660 3661 TargetExperimentalProperties::TargetExperimentalProperties() : 3662 Properties(OptionValuePropertiesSP(new TargetExperimentalOptionValueProperties())) 3663 { 3664 m_collection_sp->Initialize(g_experimental_properties); 3665 } 3666 3667 //---------------------------------------------------------------------- 3668 // TargetProperties 3669 //---------------------------------------------------------------------- 3670 TargetProperties::TargetProperties (Target *target) : 3671 Properties (), 3672 m_launch_info () 3673 { 3674 if (target) 3675 { 3676 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties())); 3677 3678 // Set callbacks to update launch_info whenever "settins set" updated any of these properties 3679 m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this); 3680 m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this); 3681 m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this); 3682 m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this); 3683 m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this); 3684 m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this); 3685 m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this); 3686 m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this); 3687 m_collection_sp->SetValueChangedCallback(ePropertyDisableSTDIO, TargetProperties::DisableSTDIOValueChangedCallback, this); 3688 3689 m_experimental_properties_up.reset(new TargetExperimentalProperties()); 3690 m_collection_sp->AppendProperty (ConstString(Properties::GetExperimentalSettingsName()), 3691 ConstString("Experimental settings - setting these won't produce errors if the setting is not present."), 3692 true, 3693 m_experimental_properties_up->GetValueProperties()); 3694 3695 // Update m_launch_info once it was created 3696 Arg0ValueChangedCallback(this, nullptr); 3697 RunArgsValueChangedCallback(this, nullptr); 3698 //EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause segfault in Target::GetPlatform() 3699 InputPathValueChangedCallback(this, nullptr); 3700 OutputPathValueChangedCallback(this, nullptr); 3701 ErrorPathValueChangedCallback(this, nullptr); 3702 DetachOnErrorValueChangedCallback(this, nullptr); 3703 DisableASLRValueChangedCallback(this, nullptr); 3704 DisableSTDIOValueChangedCallback(this, nullptr); 3705 } 3706 else 3707 { 3708 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target"))); 3709 m_collection_sp->Initialize(g_properties); 3710 m_experimental_properties_up.reset(new TargetExperimentalProperties()); 3711 m_collection_sp->AppendProperty (ConstString(Properties::GetExperimentalSettingsName()), 3712 ConstString("Experimental settings - setting these won't produce errors if the setting is not present."), 3713 true, 3714 m_experimental_properties_up->GetValueProperties()); 3715 m_collection_sp->AppendProperty(ConstString("process"), 3716 ConstString("Settings specific to processes."), 3717 true, 3718 Process::GetGlobalProperties()->GetValueProperties()); 3719 } 3720 } 3721 3722 TargetProperties::~TargetProperties() = default; 3723 3724 bool 3725 TargetProperties::GetInjectLocalVariables(ExecutionContext *exe_ctx) const 3726 { 3727 const Property *exp_property = m_collection_sp->GetPropertyAtIndex(exe_ctx, false, ePropertyExperimental); 3728 OptionValueProperties *exp_values = exp_property->GetValue()->GetAsProperties(); 3729 if (exp_values) 3730 return exp_values->GetPropertyAtIndexAsBoolean(exe_ctx, ePropertyInjectLocalVars, true); 3731 else 3732 return true; 3733 } 3734 3735 void 3736 TargetProperties::SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b) 3737 { 3738 const Property *exp_property = m_collection_sp->GetPropertyAtIndex(exe_ctx, true, ePropertyExperimental); 3739 OptionValueProperties *exp_values = exp_property->GetValue()->GetAsProperties(); 3740 if (exp_values) 3741 exp_values->SetPropertyAtIndexAsBoolean(exe_ctx, ePropertyInjectLocalVars, true); 3742 } 3743 3744 ArchSpec 3745 TargetProperties::GetDefaultArchitecture () const 3746 { 3747 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch); 3748 if (value) 3749 return value->GetCurrentValue(); 3750 return ArchSpec(); 3751 } 3752 3753 void 3754 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch) 3755 { 3756 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch); 3757 if (value) 3758 return value->SetCurrentValue(arch, true); 3759 } 3760 3761 bool 3762 TargetProperties::GetMoveToNearestCode() const 3763 { 3764 const uint32_t idx = ePropertyMoveToNearestCode; 3765 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3766 } 3767 3768 lldb::DynamicValueType 3769 TargetProperties::GetPreferDynamicValue() const 3770 { 3771 const uint32_t idx = ePropertyPreferDynamic; 3772 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 3773 } 3774 3775 bool 3776 TargetProperties::SetPreferDynamicValue (lldb::DynamicValueType d) 3777 { 3778 const uint32_t idx = ePropertyPreferDynamic; 3779 return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, d); 3780 } 3781 3782 bool 3783 TargetProperties::GetDisableASLR () const 3784 { 3785 const uint32_t idx = ePropertyDisableASLR; 3786 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3787 } 3788 3789 void 3790 TargetProperties::SetDisableASLR (bool b) 3791 { 3792 const uint32_t idx = ePropertyDisableASLR; 3793 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 3794 } 3795 3796 bool 3797 TargetProperties::GetDetachOnError () const 3798 { 3799 const uint32_t idx = ePropertyDetachOnError; 3800 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3801 } 3802 3803 void 3804 TargetProperties::SetDetachOnError (bool b) 3805 { 3806 const uint32_t idx = ePropertyDetachOnError; 3807 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 3808 } 3809 3810 bool 3811 TargetProperties::GetDisableSTDIO () const 3812 { 3813 const uint32_t idx = ePropertyDisableSTDIO; 3814 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3815 } 3816 3817 void 3818 TargetProperties::SetDisableSTDIO (bool b) 3819 { 3820 const uint32_t idx = ePropertyDisableSTDIO; 3821 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 3822 } 3823 3824 const char * 3825 TargetProperties::GetDisassemblyFlavor () const 3826 { 3827 const uint32_t idx = ePropertyDisassemblyFlavor; 3828 const char *return_value; 3829 3830 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 3831 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value; 3832 return return_value; 3833 } 3834 3835 InlineStrategy 3836 TargetProperties::GetInlineStrategy () const 3837 { 3838 const uint32_t idx = ePropertyInlineStrategy; 3839 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 3840 } 3841 3842 const char * 3843 TargetProperties::GetArg0 () const 3844 { 3845 const uint32_t idx = ePropertyArg0; 3846 return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, nullptr); 3847 } 3848 3849 void 3850 TargetProperties::SetArg0 (const char *arg) 3851 { 3852 const uint32_t idx = ePropertyArg0; 3853 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, arg); 3854 m_launch_info.SetArg0(arg); 3855 } 3856 3857 bool 3858 TargetProperties::GetRunArguments (Args &args) const 3859 { 3860 const uint32_t idx = ePropertyRunArgs; 3861 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args); 3862 } 3863 3864 void 3865 TargetProperties::SetRunArguments (const Args &args) 3866 { 3867 const uint32_t idx = ePropertyRunArgs; 3868 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args); 3869 m_launch_info.GetArguments() = args; 3870 } 3871 3872 size_t 3873 TargetProperties::GetEnvironmentAsArgs (Args &env) const 3874 { 3875 const uint32_t idx = ePropertyEnvVars; 3876 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env); 3877 } 3878 3879 void 3880 TargetProperties::SetEnvironmentFromArgs (const Args &env) 3881 { 3882 const uint32_t idx = ePropertyEnvVars; 3883 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, env); 3884 m_launch_info.GetEnvironmentEntries() = env; 3885 } 3886 3887 bool 3888 TargetProperties::GetSkipPrologue() const 3889 { 3890 const uint32_t idx = ePropertySkipPrologue; 3891 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3892 } 3893 3894 PathMappingList & 3895 TargetProperties::GetSourcePathMap () const 3896 { 3897 const uint32_t idx = ePropertySourceMap; 3898 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings(nullptr, false, idx); 3899 assert(option_value); 3900 return option_value->GetCurrentValue(); 3901 } 3902 3903 FileSpecList & 3904 TargetProperties::GetExecutableSearchPaths () 3905 { 3906 const uint32_t idx = ePropertyExecutableSearchPaths; 3907 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx); 3908 assert(option_value); 3909 return option_value->GetCurrentValue(); 3910 } 3911 3912 FileSpecList & 3913 TargetProperties::GetDebugFileSearchPaths () 3914 { 3915 const uint32_t idx = ePropertyDebugFileSearchPaths; 3916 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx); 3917 assert(option_value); 3918 return option_value->GetCurrentValue(); 3919 } 3920 3921 FileSpecList & 3922 TargetProperties::GetClangModuleSearchPaths () 3923 { 3924 const uint32_t idx = ePropertyClangModuleSearchPaths; 3925 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx); 3926 assert(option_value); 3927 return option_value->GetCurrentValue(); 3928 } 3929 3930 bool 3931 TargetProperties::GetEnableAutoImportClangModules() const 3932 { 3933 const uint32_t idx = ePropertyAutoImportClangModules; 3934 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3935 } 3936 3937 bool 3938 TargetProperties::GetEnableAutoApplyFixIts() const 3939 { 3940 const uint32_t idx = ePropertyAutoApplyFixIts; 3941 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3942 } 3943 3944 bool 3945 TargetProperties::GetEnableNotifyAboutFixIts() const 3946 { 3947 const uint32_t idx = ePropertyNotifyAboutFixIts; 3948 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3949 } 3950 3951 bool 3952 TargetProperties::GetEnableSyntheticValue () const 3953 { 3954 const uint32_t idx = ePropertyEnableSynthetic; 3955 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3956 } 3957 3958 uint32_t 3959 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const 3960 { 3961 const uint32_t idx = ePropertyMaxChildrenCount; 3962 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 3963 } 3964 3965 uint32_t 3966 TargetProperties::GetMaximumSizeOfStringSummary() const 3967 { 3968 const uint32_t idx = ePropertyMaxSummaryLength; 3969 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 3970 } 3971 3972 uint32_t 3973 TargetProperties::GetMaximumMemReadSize () const 3974 { 3975 const uint32_t idx = ePropertyMaxMemReadSize; 3976 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 3977 } 3978 3979 FileSpec 3980 TargetProperties::GetStandardInputPath () const 3981 { 3982 const uint32_t idx = ePropertyInputPath; 3983 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 3984 } 3985 3986 void 3987 TargetProperties::SetStandardInputPath (const char *p) 3988 { 3989 const uint32_t idx = ePropertyInputPath; 3990 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 3991 } 3992 3993 FileSpec 3994 TargetProperties::GetStandardOutputPath () const 3995 { 3996 const uint32_t idx = ePropertyOutputPath; 3997 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 3998 } 3999 4000 void 4001 TargetProperties::SetStandardOutputPath (const char *p) 4002 { 4003 const uint32_t idx = ePropertyOutputPath; 4004 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 4005 } 4006 4007 FileSpec 4008 TargetProperties::GetStandardErrorPath () const 4009 { 4010 const uint32_t idx = ePropertyErrorPath; 4011 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 4012 } 4013 4014 LanguageType 4015 TargetProperties::GetLanguage () const 4016 { 4017 OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(nullptr, ePropertyLanguage); 4018 if (value) 4019 return value->GetCurrentValue(); 4020 return LanguageType(); 4021 } 4022 4023 const char * 4024 TargetProperties::GetExpressionPrefixContentsAsCString () 4025 { 4026 const uint32_t idx = ePropertyExprPrefix; 4027 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false, idx); 4028 if (file) 4029 { 4030 const bool null_terminate = true; 4031 DataBufferSP data_sp(file->GetFileContents(null_terminate)); 4032 if (data_sp) 4033 return (const char *) data_sp->GetBytes(); 4034 } 4035 return nullptr; 4036 } 4037 4038 void 4039 TargetProperties::SetStandardErrorPath (const char *p) 4040 { 4041 const uint32_t idx = ePropertyErrorPath; 4042 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 4043 } 4044 4045 bool 4046 TargetProperties::GetBreakpointsConsultPlatformAvoidList () 4047 { 4048 const uint32_t idx = ePropertyBreakpointUseAvoidList; 4049 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4050 } 4051 4052 bool 4053 TargetProperties::GetUseHexImmediates () const 4054 { 4055 const uint32_t idx = ePropertyUseHexImmediates; 4056 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4057 } 4058 4059 bool 4060 TargetProperties::GetUseFastStepping () const 4061 { 4062 const uint32_t idx = ePropertyUseFastStepping; 4063 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4064 } 4065 4066 bool 4067 TargetProperties::GetDisplayExpressionsInCrashlogs () const 4068 { 4069 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs; 4070 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4071 } 4072 4073 LoadScriptFromSymFile 4074 TargetProperties::GetLoadScriptFromSymbolFile () const 4075 { 4076 const uint32_t idx = ePropertyLoadScriptFromSymbolFile; 4077 return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4078 } 4079 4080 LoadCWDlldbinitFile 4081 TargetProperties::GetLoadCWDlldbinitFile () const 4082 { 4083 const uint32_t idx = ePropertyLoadCWDlldbinitFile; 4084 return (LoadCWDlldbinitFile) m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4085 } 4086 4087 Disassembler::HexImmediateStyle 4088 TargetProperties::GetHexImmediateStyle () const 4089 { 4090 const uint32_t idx = ePropertyHexImmediateStyle; 4091 return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4092 } 4093 4094 MemoryModuleLoadLevel 4095 TargetProperties::GetMemoryModuleLoadLevel() const 4096 { 4097 const uint32_t idx = ePropertyMemoryModuleLoadLevel; 4098 return (MemoryModuleLoadLevel)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4099 } 4100 4101 bool 4102 TargetProperties::GetUserSpecifiedTrapHandlerNames (Args &args) const 4103 { 4104 const uint32_t idx = ePropertyTrapHandlerNames; 4105 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args); 4106 } 4107 4108 void 4109 TargetProperties::SetUserSpecifiedTrapHandlerNames (const Args &args) 4110 { 4111 const uint32_t idx = ePropertyTrapHandlerNames; 4112 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args); 4113 } 4114 4115 bool 4116 TargetProperties::GetDisplayRuntimeSupportValues () const 4117 { 4118 const uint32_t idx = ePropertyDisplayRuntimeSupportValues; 4119 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false); 4120 } 4121 4122 void 4123 TargetProperties::SetDisplayRuntimeSupportValues (bool b) 4124 { 4125 const uint32_t idx = ePropertyDisplayRuntimeSupportValues; 4126 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 4127 } 4128 4129 bool 4130 TargetProperties::GetNonStopModeEnabled () const 4131 { 4132 const uint32_t idx = ePropertyNonStopModeEnabled; 4133 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false); 4134 } 4135 4136 void 4137 TargetProperties::SetNonStopModeEnabled (bool b) 4138 { 4139 const uint32_t idx = ePropertyNonStopModeEnabled; 4140 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 4141 } 4142 4143 const ProcessLaunchInfo & 4144 TargetProperties::GetProcessLaunchInfo () 4145 { 4146 m_launch_info.SetArg0(GetArg0()); // FIXME: Arg0 callback doesn't work 4147 return m_launch_info; 4148 } 4149 4150 void 4151 TargetProperties::SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info) 4152 { 4153 m_launch_info = launch_info; 4154 SetArg0(launch_info.GetArg0()); 4155 SetRunArguments(launch_info.GetArguments()); 4156 SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries()); 4157 const FileAction *input_file_action = launch_info.GetFileActionForFD(STDIN_FILENO); 4158 if (input_file_action) 4159 { 4160 const char *input_path = input_file_action->GetPath(); 4161 if (input_path) 4162 SetStandardInputPath(input_path); 4163 } 4164 const FileAction *output_file_action = launch_info.GetFileActionForFD(STDOUT_FILENO); 4165 if (output_file_action) 4166 { 4167 const char *output_path = output_file_action->GetPath(); 4168 if (output_path) 4169 SetStandardOutputPath(output_path); 4170 } 4171 const FileAction *error_file_action = launch_info.GetFileActionForFD(STDERR_FILENO); 4172 if (error_file_action) 4173 { 4174 const char *error_path = error_file_action->GetPath(); 4175 if (error_path) 4176 SetStandardErrorPath(error_path); 4177 } 4178 SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError)); 4179 SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR)); 4180 SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO)); 4181 } 4182 4183 void 4184 TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *) 4185 { 4186 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4187 this_->m_launch_info.SetArg0(this_->GetArg0()); 4188 } 4189 4190 void 4191 TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *) 4192 { 4193 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4194 Args args; 4195 if (this_->GetRunArguments(args)) 4196 this_->m_launch_info.GetArguments() = args; 4197 } 4198 4199 void 4200 TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *) 4201 { 4202 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4203 Args args; 4204 if (this_->GetEnvironmentAsArgs(args)) 4205 this_->m_launch_info.GetEnvironmentEntries() = args; 4206 } 4207 4208 void 4209 TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *) 4210 { 4211 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4212 this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath(), true, false); 4213 } 4214 4215 void 4216 TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *) 4217 { 4218 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4219 this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath(), false, true); 4220 } 4221 4222 void 4223 TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *) 4224 { 4225 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4226 this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath(), false, true); 4227 } 4228 4229 void 4230 TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *) 4231 { 4232 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4233 if (this_->GetDetachOnError()) 4234 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError); 4235 else 4236 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError); 4237 } 4238 4239 void 4240 TargetProperties::DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *) 4241 { 4242 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4243 if (this_->GetDisableASLR()) 4244 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR); 4245 else 4246 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR); 4247 } 4248 4249 void 4250 TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *) 4251 { 4252 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4253 if (this_->GetDisableSTDIO()) 4254 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO); 4255 else 4256 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO); 4257 } 4258 4259 //---------------------------------------------------------------------- 4260 // Target::TargetEventData 4261 //---------------------------------------------------------------------- 4262 4263 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp) : 4264 EventData (), 4265 m_target_sp (target_sp), 4266 m_module_list () 4267 { 4268 } 4269 4270 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list) : 4271 EventData (), 4272 m_target_sp (target_sp), 4273 m_module_list (module_list) 4274 { 4275 } 4276 4277 Target::TargetEventData::~TargetEventData() = default; 4278 4279 const ConstString & 4280 Target::TargetEventData::GetFlavorString () 4281 { 4282 static ConstString g_flavor ("Target::TargetEventData"); 4283 return g_flavor; 4284 } 4285 4286 void 4287 Target::TargetEventData::Dump (Stream *s) const 4288 { 4289 for (size_t i = 0; i < m_module_list.GetSize(); ++i) 4290 { 4291 if (i != 0) 4292 *s << ", "; 4293 m_module_list.GetModuleAtIndex(i)->GetDescription(s, lldb::eDescriptionLevelBrief); 4294 } 4295 } 4296 4297 const Target::TargetEventData * 4298 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr) 4299 { 4300 if (event_ptr) 4301 { 4302 const EventData *event_data = event_ptr->GetData(); 4303 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString()) 4304 return static_cast <const TargetEventData *> (event_ptr->GetData()); 4305 } 4306 return nullptr; 4307 } 4308 4309 TargetSP 4310 Target::TargetEventData::GetTargetFromEvent (const Event *event_ptr) 4311 { 4312 TargetSP target_sp; 4313 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr); 4314 if (event_data) 4315 target_sp = event_data->m_target_sp; 4316 return target_sp; 4317 } 4318 4319 ModuleList 4320 Target::TargetEventData::GetModuleListFromEvent (const Event *event_ptr) 4321 { 4322 ModuleList module_list; 4323 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr); 4324 if (event_data) 4325 module_list = event_data->m_module_list; 4326 return module_list; 4327 } 4328