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