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 (__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(nullptr, nullptr, false, hijack_listener_sp, nullptr); 3107 3108 if (state == eStateStopped) 3109 { 3110 if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) 3111 { 3112 if (synchronous_execution) 3113 { 3114 error = m_process_sp->PrivateResume(); 3115 if (error.Success()) 3116 { 3117 state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, true, hijack_listener_sp, stream); 3118 const bool must_be_alive = false; // eStateExited is ok, so this must be false 3119 if (!StateIsStoppedState(state, must_be_alive)) 3120 { 3121 error.SetErrorStringWithFormat("process isn't stopped: %s", StateAsCString(state)); 3122 } 3123 } 3124 } 3125 else 3126 { 3127 m_process_sp->RestoreProcessEvents(); 3128 error = m_process_sp->PrivateResume(); 3129 } 3130 if (!error.Success()) 3131 { 3132 Error error2; 3133 error2.SetErrorStringWithFormat("process resume at entry point failed: %s", error.AsCString()); 3134 error = error2; 3135 } 3136 } 3137 } 3138 else if (state == eStateExited) 3139 { 3140 bool with_shell = !!launch_info.GetShell(); 3141 const int exit_status = m_process_sp->GetExitStatus(); 3142 const char *exit_desc = m_process_sp->GetExitDescription(); 3143 #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'." 3144 if (exit_desc && exit_desc[0]) 3145 { 3146 if (with_shell) 3147 error.SetErrorStringWithFormat ("process exited with status %i (%s)" LAUNCH_SHELL_MESSAGE, exit_status, exit_desc); 3148 else 3149 error.SetErrorStringWithFormat ("process exited with status %i (%s)", exit_status, exit_desc); 3150 } 3151 else 3152 { 3153 if (with_shell) 3154 error.SetErrorStringWithFormat ("process exited with status %i" LAUNCH_SHELL_MESSAGE, exit_status); 3155 else 3156 error.SetErrorStringWithFormat ("process exited with status %i", exit_status); 3157 } 3158 } 3159 else 3160 { 3161 error.SetErrorStringWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state)); 3162 } 3163 } 3164 m_process_sp->RestoreProcessEvents (); 3165 } 3166 else 3167 { 3168 Error error2; 3169 error2.SetErrorStringWithFormat ("process launch failed: %s", error.AsCString()); 3170 error = error2; 3171 } 3172 return error; 3173 } 3174 3175 Error 3176 Target::Attach (ProcessAttachInfo &attach_info, Stream *stream) 3177 { 3178 auto state = eStateInvalid; 3179 auto process_sp = GetProcessSP (); 3180 if (process_sp) 3181 { 3182 state = process_sp->GetState (); 3183 if (process_sp->IsAlive () && state != eStateConnected) 3184 { 3185 if (state == eStateAttaching) 3186 return Error ("process attach is in progress"); 3187 return Error ("a process is already being debugged"); 3188 } 3189 } 3190 3191 const ModuleSP old_exec_module_sp = GetExecutableModule (); 3192 3193 // If no process info was specified, then use the target executable 3194 // name as the process to attach to by default 3195 if (!attach_info.ProcessInfoSpecified ()) 3196 { 3197 if (old_exec_module_sp) 3198 attach_info.GetExecutableFile ().GetFilename () = old_exec_module_sp->GetPlatformFileSpec ().GetFilename (); 3199 3200 if (!attach_info.ProcessInfoSpecified ()) 3201 { 3202 return Error ("no process specified, create a target with a file, or specify the --pid or --name"); 3203 } 3204 } 3205 3206 const auto platform_sp = GetDebugger ().GetPlatformList ().GetSelectedPlatform (); 3207 ListenerSP hijack_listener_sp; 3208 const bool async = attach_info.GetAsync(); 3209 if (!async) 3210 { 3211 hijack_listener_sp = Listener::MakeListener("lldb.Target.Attach.attach.hijack"); 3212 attach_info.SetHijackListener (hijack_listener_sp); 3213 } 3214 3215 Error error; 3216 if (state != eStateConnected && platform_sp != nullptr && platform_sp->CanDebugProcess ()) 3217 { 3218 SetPlatform (platform_sp); 3219 process_sp = platform_sp->Attach (attach_info, GetDebugger (), this, error); 3220 } 3221 else 3222 { 3223 if (state != eStateConnected) 3224 { 3225 const char *plugin_name = attach_info.GetProcessPluginName (); 3226 process_sp = CreateProcess (attach_info.GetListenerForProcess (GetDebugger ()), plugin_name, nullptr); 3227 if (process_sp == nullptr) 3228 { 3229 error.SetErrorStringWithFormat ("failed to create process using plugin %s", (plugin_name) ? plugin_name : "null"); 3230 return error; 3231 } 3232 } 3233 if (hijack_listener_sp) 3234 process_sp->HijackProcessEvents (hijack_listener_sp); 3235 error = process_sp->Attach (attach_info); 3236 } 3237 3238 if (error.Success () && process_sp) 3239 { 3240 if (async) 3241 { 3242 process_sp->RestoreProcessEvents (); 3243 } 3244 else 3245 { 3246 state = process_sp->WaitForProcessToStop (nullptr, nullptr, false, attach_info.GetHijackListener(), stream); 3247 process_sp->RestoreProcessEvents (); 3248 3249 if (state != eStateStopped) 3250 { 3251 const char *exit_desc = process_sp->GetExitDescription (); 3252 if (exit_desc) 3253 error.SetErrorStringWithFormat ("%s", exit_desc); 3254 else 3255 error.SetErrorString ("process did not stop (no such process or permission problem?)"); 3256 process_sp->Destroy (false); 3257 } 3258 } 3259 } 3260 return error; 3261 } 3262 3263 //-------------------------------------------------------------- 3264 // Target::StopHook 3265 //-------------------------------------------------------------- 3266 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : 3267 UserID (uid), 3268 m_target_sp (target_sp), 3269 m_commands (), 3270 m_specifier_sp (), 3271 m_thread_spec_ap(), 3272 m_active (true) 3273 { 3274 } 3275 3276 Target::StopHook::StopHook (const StopHook &rhs) : 3277 UserID (rhs.GetID()), 3278 m_target_sp (rhs.m_target_sp), 3279 m_commands (rhs.m_commands), 3280 m_specifier_sp (rhs.m_specifier_sp), 3281 m_thread_spec_ap (), 3282 m_active (rhs.m_active) 3283 { 3284 if (rhs.m_thread_spec_ap) 3285 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); 3286 } 3287 3288 Target::StopHook::~StopHook() = default; 3289 3290 void 3291 Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier) 3292 { 3293 m_specifier_sp.reset(specifier); 3294 } 3295 3296 void 3297 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) 3298 { 3299 m_thread_spec_ap.reset (specifier); 3300 } 3301 3302 void 3303 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const 3304 { 3305 int indent_level = s->GetIndentLevel(); 3306 3307 s->SetIndentLevel(indent_level + 2); 3308 3309 s->Printf ("Hook: %" PRIu64 "\n", GetID()); 3310 if (m_active) 3311 s->Indent ("State: enabled\n"); 3312 else 3313 s->Indent ("State: disabled\n"); 3314 3315 if (m_specifier_sp) 3316 { 3317 s->Indent(); 3318 s->PutCString ("Specifier:\n"); 3319 s->SetIndentLevel (indent_level + 4); 3320 m_specifier_sp->GetDescription (s, level); 3321 s->SetIndentLevel (indent_level + 2); 3322 } 3323 3324 if (m_thread_spec_ap) 3325 { 3326 StreamString tmp; 3327 s->Indent("Thread:\n"); 3328 m_thread_spec_ap->GetDescription (&tmp, level); 3329 s->SetIndentLevel (indent_level + 4); 3330 s->Indent (tmp.GetData()); 3331 s->PutCString ("\n"); 3332 s->SetIndentLevel (indent_level + 2); 3333 } 3334 3335 s->Indent ("Commands: \n"); 3336 s->SetIndentLevel (indent_level + 4); 3337 uint32_t num_commands = m_commands.GetSize(); 3338 for (uint32_t i = 0; i < num_commands; i++) 3339 { 3340 s->Indent(m_commands.GetStringAtIndex(i)); 3341 s->PutCString ("\n"); 3342 } 3343 s->SetIndentLevel (indent_level); 3344 } 3345 3346 //-------------------------------------------------------------- 3347 // class TargetProperties 3348 //-------------------------------------------------------------- 3349 3350 OptionEnumValueElement 3351 lldb_private::g_dynamic_value_types[] = 3352 { 3353 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"}, 3354 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."}, 3355 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."}, 3356 { 0, nullptr, nullptr } 3357 }; 3358 3359 static OptionEnumValueElement 3360 g_inline_breakpoint_enums[] = 3361 { 3362 { 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."}, 3363 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."}, 3364 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."}, 3365 { 0, nullptr, nullptr } 3366 }; 3367 3368 typedef enum x86DisassemblyFlavor 3369 { 3370 eX86DisFlavorDefault, 3371 eX86DisFlavorIntel, 3372 eX86DisFlavorATT 3373 } x86DisassemblyFlavor; 3374 3375 static OptionEnumValueElement 3376 g_x86_dis_flavor_value_types[] = 3377 { 3378 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."}, 3379 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."}, 3380 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."}, 3381 { 0, nullptr, nullptr } 3382 }; 3383 3384 static OptionEnumValueElement 3385 g_hex_immediate_style_values[] = 3386 { 3387 { Disassembler::eHexStyleC, "c", "C-style (0xffff)."}, 3388 { Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."}, 3389 { 0, nullptr, nullptr } 3390 }; 3391 3392 static OptionEnumValueElement 3393 g_load_script_from_sym_file_values[] = 3394 { 3395 { eLoadScriptFromSymFileTrue, "true", "Load debug scripts inside symbol files"}, 3396 { eLoadScriptFromSymFileFalse, "false", "Do not load debug scripts inside symbol files."}, 3397 { eLoadScriptFromSymFileWarn, "warn", "Warn about debug scripts inside symbol files but do not load them."}, 3398 { 0, nullptr, nullptr } 3399 }; 3400 3401 static OptionEnumValueElement 3402 g_load_current_working_dir_lldbinit_values[] = 3403 { 3404 { eLoadCWDlldbinitTrue, "true", "Load .lldbinit files from current directory"}, 3405 { eLoadCWDlldbinitFalse, "false", "Do not load .lldbinit files from current directory"}, 3406 { eLoadCWDlldbinitWarn, "warn", "Warn about loading .lldbinit files from current directory"}, 3407 { 0, nullptr, nullptr } 3408 }; 3409 3410 static OptionEnumValueElement 3411 g_memory_module_load_level_values[] = 3412 { 3413 { eMemoryModuleLoadLevelMinimal, "minimal" , "Load minimal information when loading modules from memory. Currently this setting loads sections only."}, 3414 { eMemoryModuleLoadLevelPartial, "partial" , "Load partial information when loading modules from memory. Currently this setting loads sections and function bounds."}, 3415 { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."}, 3416 { 0, nullptr, nullptr } 3417 }; 3418 3419 static PropertyDefinition 3420 g_properties[] = 3421 { 3422 { "default-arch" , OptionValue::eTypeArch , true , 0 , nullptr, nullptr, "Default architecture to choose, when there's a choice." }, 3423 { "move-to-nearest-code" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Move breakpoints to nearest code." }, 3424 { "language" , OptionValue::eTypeLanguage , false, eLanguageTypeUnknown , nullptr, nullptr, "The language to use when interpreting expressions entered in commands." }, 3425 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "Path to a file containing expressions to be prepended to all expressions." }, 3426 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eDynamicDontRunTarget , nullptr, g_dynamic_value_types, "Should printed values be shown as their dynamic value." }, 3427 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Should synthetic values be used by default whenever available." }, 3428 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Skip function prologues when setting breakpoints by name." }, 3429 { "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 " 3430 "where it exists on the current system. It consists of an array of duples, the first element of each duple is " 3431 "some part (starting at the root) of the path to the file when it was built, " 3432 "and the second is where the remainder of the original build hierarchy is rooted on the local system. " 3433 "Each element of the array is checked in order and the first one that results in a match wins." }, 3434 { "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." }, 3435 { "debug-file-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "List of directories to be searched when locating debug symbol files." }, 3436 { "clang-module-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "List of directories to be searched when locating modules for Clang." }, 3437 { "auto-import-clang-modules" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Automatically load Clang modules referred to by the program." }, 3438 { "auto-apply-fixits" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Automatically apply fix-it hints to expressions." }, 3439 { "notify-about-fixits" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Print the fixed expression text." }, 3440 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , nullptr, nullptr, "Maximum number of children to expand in any level of depth." }, 3441 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , nullptr, nullptr, "Maximum number of characters to show when using %s in summary strings." }, 3442 { "max-memory-read-size" , OptionValue::eTypeSInt64 , false, 1024 , nullptr, nullptr, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." }, 3443 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Consult the platform module avoid list when setting non-module specific breakpoints." }, 3444 { "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." }, 3445 { "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." }, 3446 { "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." }, 3447 { "inherit-env" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Inherit the environment from the process that is running LLDB." }, 3448 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for reading its standard input." }, 3449 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard output." }, 3450 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard error." }, 3451 { "detach-on-error" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "debugserver will detach (rather than killing) a process if it loses connection with lldb." }, 3452 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Disable Address Space Layout Randomization (ASLR)" }, 3453 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , nullptr, nullptr, "Disable stdin/stdout for process (e.g. for a GUI application)" }, 3454 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsAlways , nullptr, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. " 3455 "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. " 3456 "Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. " 3457 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. " 3458 "Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers " 3459 "and find that setting breakpoints is slow, then you can change this setting to headers. " 3460 "This setting allows you to control exactly which strategy is used when setting " 3461 "file and line breakpoints." }, 3462 // 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. 3463 { "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." }, 3464 { "use-hex-immediates" , OptionValue::eTypeBoolean , false, true, nullptr, nullptr, "Show immediates in disassembly as hexadecimal." }, 3465 { "hex-immediate-style" , OptionValue::eTypeEnum , false, Disassembler::eHexStyleC, nullptr, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." }, 3466 { "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." }, 3467 { "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." }, 3468 { "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." }, 3469 { "memory-module-load-level" , OptionValue::eTypeEnum , false, eMemoryModuleLoadLevelComplete, nullptr, g_memory_module_load_level_values, 3470 "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. " 3471 "This setting helps users control how much information gets loaded when loading modules from memory." 3472 "'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). " 3473 "'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). " 3474 "'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). " }, 3475 { "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." }, 3476 { "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." }, 3477 { "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." }, 3478 { "non-stop-mode" , OptionValue::eTypeBoolean , false, 0, nullptr, nullptr, "Disable lock-step debugging, instead control threads independently." }, 3479 { nullptr , OptionValue::eTypeInvalid , false, 0 , nullptr, nullptr, nullptr } 3480 }; 3481 3482 enum 3483 { 3484 ePropertyDefaultArch, 3485 ePropertyMoveToNearestCode, 3486 ePropertyLanguage, 3487 ePropertyExprPrefix, 3488 ePropertyPreferDynamic, 3489 ePropertyEnableSynthetic, 3490 ePropertySkipPrologue, 3491 ePropertySourceMap, 3492 ePropertyExecutableSearchPaths, 3493 ePropertyDebugFileSearchPaths, 3494 ePropertyClangModuleSearchPaths, 3495 ePropertyAutoImportClangModules, 3496 ePropertyAutoApplyFixIts, 3497 ePropertyNotifyAboutFixIts, 3498 ePropertyMaxChildrenCount, 3499 ePropertyMaxSummaryLength, 3500 ePropertyMaxMemReadSize, 3501 ePropertyBreakpointUseAvoidList, 3502 ePropertyArg0, 3503 ePropertyRunArgs, 3504 ePropertyEnvVars, 3505 ePropertyInheritEnv, 3506 ePropertyInputPath, 3507 ePropertyOutputPath, 3508 ePropertyErrorPath, 3509 ePropertyDetachOnError, 3510 ePropertyDisableASLR, 3511 ePropertyDisableSTDIO, 3512 ePropertyInlineStrategy, 3513 ePropertyDisassemblyFlavor, 3514 ePropertyUseHexImmediates, 3515 ePropertyHexImmediateStyle, 3516 ePropertyUseFastStepping, 3517 ePropertyLoadScriptFromSymbolFile, 3518 ePropertyLoadCWDlldbinitFile, 3519 ePropertyMemoryModuleLoadLevel, 3520 ePropertyDisplayExpressionsInCrashlogs, 3521 ePropertyTrapHandlerNames, 3522 ePropertyDisplayRuntimeSupportValues, 3523 ePropertyNonStopModeEnabled, 3524 ePropertyExperimental 3525 }; 3526 3527 class TargetOptionValueProperties : public OptionValueProperties 3528 { 3529 public: 3530 TargetOptionValueProperties (const ConstString &name) : 3531 OptionValueProperties (name), 3532 m_target(nullptr), 3533 m_got_host_env (false) 3534 { 3535 } 3536 3537 // This constructor is used when creating TargetOptionValueProperties when it 3538 // is part of a new lldb_private::Target instance. It will copy all current 3539 // global property values as needed 3540 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) : 3541 OptionValueProperties(*target_properties_sp->GetValueProperties()), 3542 m_target (target), 3543 m_got_host_env (false) 3544 { 3545 } 3546 3547 const Property * 3548 GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override 3549 { 3550 // When getting the value for a key from the target options, we will always 3551 // try and grab the setting from the current target if there is one. Else we just 3552 // use the one from this instance. 3553 if (idx == ePropertyEnvVars) 3554 GetHostEnvironmentIfNeeded (); 3555 3556 if (exe_ctx) 3557 { 3558 Target *target = exe_ctx->GetTargetPtr(); 3559 if (target) 3560 { 3561 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get()); 3562 if (this != target_properties) 3563 return target_properties->ProtectedGetPropertyAtIndex (idx); 3564 } 3565 } 3566 return ProtectedGetPropertyAtIndex (idx); 3567 } 3568 3569 lldb::TargetSP 3570 GetTargetSP () 3571 { 3572 return m_target->shared_from_this(); 3573 } 3574 3575 protected: 3576 void 3577 GetHostEnvironmentIfNeeded () const 3578 { 3579 if (!m_got_host_env) 3580 { 3581 if (m_target) 3582 { 3583 m_got_host_env = true; 3584 const uint32_t idx = ePropertyInheritEnv; 3585 if (GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0)) 3586 { 3587 PlatformSP platform_sp (m_target->GetPlatform()); 3588 if (platform_sp) 3589 { 3590 StringList env; 3591 if (platform_sp->GetEnvironment(env)) 3592 { 3593 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary(nullptr, ePropertyEnvVars); 3594 if (env_dict) 3595 { 3596 const bool can_replace = false; 3597 const size_t envc = env.GetSize(); 3598 for (size_t idx=0; idx<envc; idx++) 3599 { 3600 const char *env_entry = env.GetStringAtIndex (idx); 3601 if (env_entry) 3602 { 3603 const char *equal_pos = ::strchr(env_entry, '='); 3604 ConstString key; 3605 // It is ok to have environment variables with no values 3606 const char *value = nullptr; 3607 if (equal_pos) 3608 { 3609 key.SetCStringWithLength(env_entry, equal_pos - env_entry); 3610 if (equal_pos[1]) 3611 value = equal_pos + 1; 3612 } 3613 else 3614 { 3615 key.SetCString(env_entry); 3616 } 3617 // Don't allow existing keys to be replaced with ones we get from the platform environment 3618 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace); 3619 } 3620 } 3621 } 3622 } 3623 } 3624 } 3625 } 3626 } 3627 } 3628 Target *m_target; 3629 mutable bool m_got_host_env; 3630 }; 3631 3632 //---------------------------------------------------------------------- 3633 // TargetProperties 3634 //---------------------------------------------------------------------- 3635 static PropertyDefinition 3636 g_experimental_properties[] 3637 { 3638 { "inject-local-vars", OptionValue::eTypeBoolean , true, true, nullptr, nullptr, "If true, inject local variables explicitly into the expression text. " 3639 "This will fix symbol resolution when there are name collisions between ivars and local variables. " 3640 "But it can make expressions run much more slowly." }, 3641 { nullptr, OptionValue::eTypeInvalid , true, 0 , nullptr, nullptr, nullptr } 3642 }; 3643 3644 enum 3645 { 3646 ePropertyInjectLocalVars = 0 3647 }; 3648 3649 class TargetExperimentalOptionValueProperties : public OptionValueProperties 3650 { 3651 public: 3652 TargetExperimentalOptionValueProperties () : 3653 OptionValueProperties (ConstString(Properties::GetExperimentalSettingsName())) 3654 { 3655 } 3656 }; 3657 3658 TargetExperimentalProperties::TargetExperimentalProperties() : 3659 Properties(OptionValuePropertiesSP(new TargetExperimentalOptionValueProperties())) 3660 { 3661 m_collection_sp->Initialize(g_experimental_properties); 3662 } 3663 3664 //---------------------------------------------------------------------- 3665 // TargetProperties 3666 //---------------------------------------------------------------------- 3667 TargetProperties::TargetProperties (Target *target) : 3668 Properties (), 3669 m_launch_info () 3670 { 3671 if (target) 3672 { 3673 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties())); 3674 3675 // Set callbacks to update launch_info whenever "settins set" updated any of these properties 3676 m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this); 3677 m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this); 3678 m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this); 3679 m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this); 3680 m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this); 3681 m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this); 3682 m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this); 3683 m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this); 3684 m_collection_sp->SetValueChangedCallback(ePropertyDisableSTDIO, TargetProperties::DisableSTDIOValueChangedCallback, this); 3685 3686 m_experimental_properties_up.reset(new TargetExperimentalProperties()); 3687 m_collection_sp->AppendProperty (ConstString(Properties::GetExperimentalSettingsName()), 3688 ConstString("Experimental settings - setting these won't produce errors if the setting is not present."), 3689 true, 3690 m_experimental_properties_up->GetValueProperties()); 3691 3692 // Update m_launch_info once it was created 3693 Arg0ValueChangedCallback(this, nullptr); 3694 RunArgsValueChangedCallback(this, nullptr); 3695 //EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause segfault in Target::GetPlatform() 3696 InputPathValueChangedCallback(this, nullptr); 3697 OutputPathValueChangedCallback(this, nullptr); 3698 ErrorPathValueChangedCallback(this, nullptr); 3699 DetachOnErrorValueChangedCallback(this, nullptr); 3700 DisableASLRValueChangedCallback(this, nullptr); 3701 DisableSTDIOValueChangedCallback(this, nullptr); 3702 } 3703 else 3704 { 3705 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target"))); 3706 m_collection_sp->Initialize(g_properties); 3707 m_experimental_properties_up.reset(new TargetExperimentalProperties()); 3708 m_collection_sp->AppendProperty (ConstString(Properties::GetExperimentalSettingsName()), 3709 ConstString("Experimental settings - setting these won't produce errors if the setting is not present."), 3710 true, 3711 m_experimental_properties_up->GetValueProperties()); 3712 m_collection_sp->AppendProperty(ConstString("process"), 3713 ConstString("Settings specific to processes."), 3714 true, 3715 Process::GetGlobalProperties()->GetValueProperties()); 3716 } 3717 } 3718 3719 TargetProperties::~TargetProperties() = default; 3720 3721 bool 3722 TargetProperties::GetInjectLocalVariables(ExecutionContext *exe_ctx) const 3723 { 3724 const Property *exp_property = m_collection_sp->GetPropertyAtIndex(exe_ctx, false, ePropertyExperimental); 3725 OptionValueProperties *exp_values = exp_property->GetValue()->GetAsProperties(); 3726 if (exp_values) 3727 return exp_values->GetPropertyAtIndexAsBoolean(exe_ctx, ePropertyInjectLocalVars, true); 3728 else 3729 return true; 3730 } 3731 3732 void 3733 TargetProperties::SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b) 3734 { 3735 const Property *exp_property = m_collection_sp->GetPropertyAtIndex(exe_ctx, true, ePropertyExperimental); 3736 OptionValueProperties *exp_values = exp_property->GetValue()->GetAsProperties(); 3737 if (exp_values) 3738 exp_values->SetPropertyAtIndexAsBoolean(exe_ctx, ePropertyInjectLocalVars, true); 3739 } 3740 3741 ArchSpec 3742 TargetProperties::GetDefaultArchitecture () const 3743 { 3744 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch); 3745 if (value) 3746 return value->GetCurrentValue(); 3747 return ArchSpec(); 3748 } 3749 3750 void 3751 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch) 3752 { 3753 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch); 3754 if (value) 3755 return value->SetCurrentValue(arch, true); 3756 } 3757 3758 bool 3759 TargetProperties::GetMoveToNearestCode() const 3760 { 3761 const uint32_t idx = ePropertyMoveToNearestCode; 3762 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3763 } 3764 3765 lldb::DynamicValueType 3766 TargetProperties::GetPreferDynamicValue() const 3767 { 3768 const uint32_t idx = ePropertyPreferDynamic; 3769 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 3770 } 3771 3772 bool 3773 TargetProperties::SetPreferDynamicValue (lldb::DynamicValueType d) 3774 { 3775 const uint32_t idx = ePropertyPreferDynamic; 3776 return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, d); 3777 } 3778 3779 bool 3780 TargetProperties::GetDisableASLR () const 3781 { 3782 const uint32_t idx = ePropertyDisableASLR; 3783 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3784 } 3785 3786 void 3787 TargetProperties::SetDisableASLR (bool b) 3788 { 3789 const uint32_t idx = ePropertyDisableASLR; 3790 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 3791 } 3792 3793 bool 3794 TargetProperties::GetDetachOnError () const 3795 { 3796 const uint32_t idx = ePropertyDetachOnError; 3797 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3798 } 3799 3800 void 3801 TargetProperties::SetDetachOnError (bool b) 3802 { 3803 const uint32_t idx = ePropertyDetachOnError; 3804 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 3805 } 3806 3807 bool 3808 TargetProperties::GetDisableSTDIO () const 3809 { 3810 const uint32_t idx = ePropertyDisableSTDIO; 3811 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3812 } 3813 3814 void 3815 TargetProperties::SetDisableSTDIO (bool b) 3816 { 3817 const uint32_t idx = ePropertyDisableSTDIO; 3818 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 3819 } 3820 3821 const char * 3822 TargetProperties::GetDisassemblyFlavor () const 3823 { 3824 const uint32_t idx = ePropertyDisassemblyFlavor; 3825 const char *return_value; 3826 3827 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 3828 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value; 3829 return return_value; 3830 } 3831 3832 InlineStrategy 3833 TargetProperties::GetInlineStrategy () const 3834 { 3835 const uint32_t idx = ePropertyInlineStrategy; 3836 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 3837 } 3838 3839 const char * 3840 TargetProperties::GetArg0 () const 3841 { 3842 const uint32_t idx = ePropertyArg0; 3843 return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, nullptr); 3844 } 3845 3846 void 3847 TargetProperties::SetArg0 (const char *arg) 3848 { 3849 const uint32_t idx = ePropertyArg0; 3850 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, arg); 3851 m_launch_info.SetArg0(arg); 3852 } 3853 3854 bool 3855 TargetProperties::GetRunArguments (Args &args) const 3856 { 3857 const uint32_t idx = ePropertyRunArgs; 3858 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args); 3859 } 3860 3861 void 3862 TargetProperties::SetRunArguments (const Args &args) 3863 { 3864 const uint32_t idx = ePropertyRunArgs; 3865 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args); 3866 m_launch_info.GetArguments() = args; 3867 } 3868 3869 size_t 3870 TargetProperties::GetEnvironmentAsArgs (Args &env) const 3871 { 3872 const uint32_t idx = ePropertyEnvVars; 3873 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env); 3874 } 3875 3876 void 3877 TargetProperties::SetEnvironmentFromArgs (const Args &env) 3878 { 3879 const uint32_t idx = ePropertyEnvVars; 3880 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, env); 3881 m_launch_info.GetEnvironmentEntries() = env; 3882 } 3883 3884 bool 3885 TargetProperties::GetSkipPrologue() const 3886 { 3887 const uint32_t idx = ePropertySkipPrologue; 3888 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3889 } 3890 3891 PathMappingList & 3892 TargetProperties::GetSourcePathMap () const 3893 { 3894 const uint32_t idx = ePropertySourceMap; 3895 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings(nullptr, false, idx); 3896 assert(option_value); 3897 return option_value->GetCurrentValue(); 3898 } 3899 3900 FileSpecList & 3901 TargetProperties::GetExecutableSearchPaths () 3902 { 3903 const uint32_t idx = ePropertyExecutableSearchPaths; 3904 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx); 3905 assert(option_value); 3906 return option_value->GetCurrentValue(); 3907 } 3908 3909 FileSpecList & 3910 TargetProperties::GetDebugFileSearchPaths () 3911 { 3912 const uint32_t idx = ePropertyDebugFileSearchPaths; 3913 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx); 3914 assert(option_value); 3915 return option_value->GetCurrentValue(); 3916 } 3917 3918 FileSpecList & 3919 TargetProperties::GetClangModuleSearchPaths () 3920 { 3921 const uint32_t idx = ePropertyClangModuleSearchPaths; 3922 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx); 3923 assert(option_value); 3924 return option_value->GetCurrentValue(); 3925 } 3926 3927 bool 3928 TargetProperties::GetEnableAutoImportClangModules() const 3929 { 3930 const uint32_t idx = ePropertyAutoImportClangModules; 3931 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3932 } 3933 3934 bool 3935 TargetProperties::GetEnableAutoApplyFixIts() const 3936 { 3937 const uint32_t idx = ePropertyAutoApplyFixIts; 3938 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3939 } 3940 3941 bool 3942 TargetProperties::GetEnableNotifyAboutFixIts() const 3943 { 3944 const uint32_t idx = ePropertyNotifyAboutFixIts; 3945 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3946 } 3947 3948 bool 3949 TargetProperties::GetEnableSyntheticValue () const 3950 { 3951 const uint32_t idx = ePropertyEnableSynthetic; 3952 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 3953 } 3954 3955 uint32_t 3956 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const 3957 { 3958 const uint32_t idx = ePropertyMaxChildrenCount; 3959 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 3960 } 3961 3962 uint32_t 3963 TargetProperties::GetMaximumSizeOfStringSummary() const 3964 { 3965 const uint32_t idx = ePropertyMaxSummaryLength; 3966 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 3967 } 3968 3969 uint32_t 3970 TargetProperties::GetMaximumMemReadSize () const 3971 { 3972 const uint32_t idx = ePropertyMaxMemReadSize; 3973 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value); 3974 } 3975 3976 FileSpec 3977 TargetProperties::GetStandardInputPath () const 3978 { 3979 const uint32_t idx = ePropertyInputPath; 3980 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 3981 } 3982 3983 void 3984 TargetProperties::SetStandardInputPath (const char *p) 3985 { 3986 const uint32_t idx = ePropertyInputPath; 3987 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 3988 } 3989 3990 FileSpec 3991 TargetProperties::GetStandardOutputPath () const 3992 { 3993 const uint32_t idx = ePropertyOutputPath; 3994 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 3995 } 3996 3997 void 3998 TargetProperties::SetStandardOutputPath (const char *p) 3999 { 4000 const uint32_t idx = ePropertyOutputPath; 4001 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 4002 } 4003 4004 FileSpec 4005 TargetProperties::GetStandardErrorPath () const 4006 { 4007 const uint32_t idx = ePropertyErrorPath; 4008 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 4009 } 4010 4011 LanguageType 4012 TargetProperties::GetLanguage () const 4013 { 4014 OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(nullptr, ePropertyLanguage); 4015 if (value) 4016 return value->GetCurrentValue(); 4017 return LanguageType(); 4018 } 4019 4020 const char * 4021 TargetProperties::GetExpressionPrefixContentsAsCString () 4022 { 4023 const uint32_t idx = ePropertyExprPrefix; 4024 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false, idx); 4025 if (file) 4026 { 4027 const bool null_terminate = true; 4028 DataBufferSP data_sp(file->GetFileContents(null_terminate)); 4029 if (data_sp) 4030 return (const char *) data_sp->GetBytes(); 4031 } 4032 return nullptr; 4033 } 4034 4035 void 4036 TargetProperties::SetStandardErrorPath (const char *p) 4037 { 4038 const uint32_t idx = ePropertyErrorPath; 4039 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p); 4040 } 4041 4042 bool 4043 TargetProperties::GetBreakpointsConsultPlatformAvoidList () 4044 { 4045 const uint32_t idx = ePropertyBreakpointUseAvoidList; 4046 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4047 } 4048 4049 bool 4050 TargetProperties::GetUseHexImmediates () const 4051 { 4052 const uint32_t idx = ePropertyUseHexImmediates; 4053 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4054 } 4055 4056 bool 4057 TargetProperties::GetUseFastStepping () const 4058 { 4059 const uint32_t idx = ePropertyUseFastStepping; 4060 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4061 } 4062 4063 bool 4064 TargetProperties::GetDisplayExpressionsInCrashlogs () const 4065 { 4066 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs; 4067 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); 4068 } 4069 4070 LoadScriptFromSymFile 4071 TargetProperties::GetLoadScriptFromSymbolFile () const 4072 { 4073 const uint32_t idx = ePropertyLoadScriptFromSymbolFile; 4074 return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4075 } 4076 4077 LoadCWDlldbinitFile 4078 TargetProperties::GetLoadCWDlldbinitFile () const 4079 { 4080 const uint32_t idx = ePropertyLoadCWDlldbinitFile; 4081 return (LoadCWDlldbinitFile) m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4082 } 4083 4084 Disassembler::HexImmediateStyle 4085 TargetProperties::GetHexImmediateStyle () const 4086 { 4087 const uint32_t idx = ePropertyHexImmediateStyle; 4088 return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4089 } 4090 4091 MemoryModuleLoadLevel 4092 TargetProperties::GetMemoryModuleLoadLevel() const 4093 { 4094 const uint32_t idx = ePropertyMemoryModuleLoadLevel; 4095 return (MemoryModuleLoadLevel)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value); 4096 } 4097 4098 bool 4099 TargetProperties::GetUserSpecifiedTrapHandlerNames (Args &args) const 4100 { 4101 const uint32_t idx = ePropertyTrapHandlerNames; 4102 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args); 4103 } 4104 4105 void 4106 TargetProperties::SetUserSpecifiedTrapHandlerNames (const Args &args) 4107 { 4108 const uint32_t idx = ePropertyTrapHandlerNames; 4109 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args); 4110 } 4111 4112 bool 4113 TargetProperties::GetDisplayRuntimeSupportValues () const 4114 { 4115 const uint32_t idx = ePropertyDisplayRuntimeSupportValues; 4116 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false); 4117 } 4118 4119 void 4120 TargetProperties::SetDisplayRuntimeSupportValues (bool b) 4121 { 4122 const uint32_t idx = ePropertyDisplayRuntimeSupportValues; 4123 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 4124 } 4125 4126 bool 4127 TargetProperties::GetNonStopModeEnabled () const 4128 { 4129 const uint32_t idx = ePropertyNonStopModeEnabled; 4130 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false); 4131 } 4132 4133 void 4134 TargetProperties::SetNonStopModeEnabled (bool b) 4135 { 4136 const uint32_t idx = ePropertyNonStopModeEnabled; 4137 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b); 4138 } 4139 4140 const ProcessLaunchInfo & 4141 TargetProperties::GetProcessLaunchInfo () 4142 { 4143 m_launch_info.SetArg0(GetArg0()); // FIXME: Arg0 callback doesn't work 4144 return m_launch_info; 4145 } 4146 4147 void 4148 TargetProperties::SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info) 4149 { 4150 m_launch_info = launch_info; 4151 SetArg0(launch_info.GetArg0()); 4152 SetRunArguments(launch_info.GetArguments()); 4153 SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries()); 4154 const FileAction *input_file_action = launch_info.GetFileActionForFD(STDIN_FILENO); 4155 if (input_file_action) 4156 { 4157 const char *input_path = input_file_action->GetPath(); 4158 if (input_path) 4159 SetStandardInputPath(input_path); 4160 } 4161 const FileAction *output_file_action = launch_info.GetFileActionForFD(STDOUT_FILENO); 4162 if (output_file_action) 4163 { 4164 const char *output_path = output_file_action->GetPath(); 4165 if (output_path) 4166 SetStandardOutputPath(output_path); 4167 } 4168 const FileAction *error_file_action = launch_info.GetFileActionForFD(STDERR_FILENO); 4169 if (error_file_action) 4170 { 4171 const char *error_path = error_file_action->GetPath(); 4172 if (error_path) 4173 SetStandardErrorPath(error_path); 4174 } 4175 SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError)); 4176 SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR)); 4177 SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO)); 4178 } 4179 4180 void 4181 TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *) 4182 { 4183 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4184 this_->m_launch_info.SetArg0(this_->GetArg0()); 4185 } 4186 4187 void 4188 TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *) 4189 { 4190 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4191 Args args; 4192 if (this_->GetRunArguments(args)) 4193 this_->m_launch_info.GetArguments() = args; 4194 } 4195 4196 void 4197 TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *) 4198 { 4199 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4200 Args args; 4201 if (this_->GetEnvironmentAsArgs(args)) 4202 this_->m_launch_info.GetEnvironmentEntries() = args; 4203 } 4204 4205 void 4206 TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *) 4207 { 4208 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4209 this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath(), true, false); 4210 } 4211 4212 void 4213 TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *) 4214 { 4215 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4216 this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath(), false, true); 4217 } 4218 4219 void 4220 TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *) 4221 { 4222 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4223 this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath(), false, true); 4224 } 4225 4226 void 4227 TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *) 4228 { 4229 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4230 if (this_->GetDetachOnError()) 4231 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError); 4232 else 4233 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError); 4234 } 4235 4236 void 4237 TargetProperties::DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *) 4238 { 4239 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4240 if (this_->GetDisableASLR()) 4241 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR); 4242 else 4243 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR); 4244 } 4245 4246 void 4247 TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *) 4248 { 4249 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 4250 if (this_->GetDisableSTDIO()) 4251 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO); 4252 else 4253 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO); 4254 } 4255 4256 //---------------------------------------------------------------------- 4257 // Target::TargetEventData 4258 //---------------------------------------------------------------------- 4259 4260 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp) : 4261 EventData (), 4262 m_target_sp (target_sp), 4263 m_module_list () 4264 { 4265 } 4266 4267 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list) : 4268 EventData (), 4269 m_target_sp (target_sp), 4270 m_module_list (module_list) 4271 { 4272 } 4273 4274 Target::TargetEventData::~TargetEventData() = default; 4275 4276 const ConstString & 4277 Target::TargetEventData::GetFlavorString () 4278 { 4279 static ConstString g_flavor ("Target::TargetEventData"); 4280 return g_flavor; 4281 } 4282 4283 void 4284 Target::TargetEventData::Dump (Stream *s) const 4285 { 4286 for (size_t i = 0; i < m_module_list.GetSize(); ++i) 4287 { 4288 if (i != 0) 4289 *s << ", "; 4290 m_module_list.GetModuleAtIndex(i)->GetDescription(s, lldb::eDescriptionLevelBrief); 4291 } 4292 } 4293 4294 const Target::TargetEventData * 4295 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr) 4296 { 4297 if (event_ptr) 4298 { 4299 const EventData *event_data = event_ptr->GetData(); 4300 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString()) 4301 return static_cast <const TargetEventData *> (event_ptr->GetData()); 4302 } 4303 return nullptr; 4304 } 4305 4306 TargetSP 4307 Target::TargetEventData::GetTargetFromEvent (const Event *event_ptr) 4308 { 4309 TargetSP target_sp; 4310 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr); 4311 if (event_data) 4312 target_sp = event_data->m_target_sp; 4313 return target_sp; 4314 } 4315 4316 ModuleList 4317 Target::TargetEventData::GetModuleListFromEvent (const Event *event_ptr) 4318 { 4319 ModuleList module_list; 4320 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr); 4321 if (event_data) 4322 module_list = event_data->m_module_list; 4323 return module_list; 4324 } 4325