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