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(false); 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 BroadcastEvent (eBroadcastBitModulesLoaded, new TargetEventData (this->shared_from_this(), module_list)); 1264 } 1265 } 1266 1267 void 1268 Target::SymbolsDidLoad (ModuleList &module_list) 1269 { 1270 if (m_valid && module_list.GetSize()) 1271 { 1272 if (m_process_sp) 1273 { 1274 LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); 1275 if (runtime) 1276 { 1277 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime; 1278 objc_runtime->SymbolsDidLoad(module_list); 1279 } 1280 } 1281 1282 m_breakpoint_list.UpdateBreakpoints (module_list, true, false); 1283 BroadcastEvent (eBroadcastBitSymbolsLoaded, new TargetEventData (this->shared_from_this(), module_list)); 1284 } 1285 } 1286 1287 void 1288 Target::ModulesDidUnload (ModuleList &module_list, bool delete_locations) 1289 { 1290 if (m_valid && module_list.GetSize()) 1291 { 1292 UnloadModuleSections (module_list); 1293 m_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations); 1294 BroadcastEvent (eBroadcastBitModulesUnloaded, new TargetEventData (this->shared_from_this(), module_list)); 1295 } 1296 } 1297 1298 bool 1299 Target::ModuleIsExcludedForUnconstrainedSearches (const FileSpec &module_file_spec) 1300 { 1301 if (GetBreakpointsConsultPlatformAvoidList()) 1302 { 1303 ModuleList matchingModules; 1304 ModuleSpec module_spec (module_file_spec); 1305 size_t num_modules = GetImages().FindModules(module_spec, matchingModules); 1306 1307 // If there is more than one module for this file spec, only return true if ALL the modules are on the 1308 // black list. 1309 if (num_modules > 0) 1310 { 1311 for (size_t i = 0; i < num_modules; i++) 1312 { 1313 if (!ModuleIsExcludedForUnconstrainedSearches (matchingModules.GetModuleAtIndex(i))) 1314 return false; 1315 } 1316 return true; 1317 } 1318 } 1319 return false; 1320 } 1321 1322 bool 1323 Target::ModuleIsExcludedForUnconstrainedSearches (const lldb::ModuleSP &module_sp) 1324 { 1325 if (GetBreakpointsConsultPlatformAvoidList()) 1326 { 1327 if (m_platform_sp) 1328 return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches (*this, module_sp); 1329 } 1330 return false; 1331 } 1332 1333 size_t 1334 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error) 1335 { 1336 SectionSP section_sp (addr.GetSection()); 1337 if (section_sp) 1338 { 1339 // If the contents of this section are encrypted, the on-disk file is unusable. Read only from live memory. 1340 if (section_sp->IsEncrypted()) 1341 { 1342 error.SetErrorString("section is encrypted"); 1343 return 0; 1344 } 1345 ModuleSP module_sp (section_sp->GetModule()); 1346 if (module_sp) 1347 { 1348 ObjectFile *objfile = section_sp->GetModule()->GetObjectFile(); 1349 if (objfile) 1350 { 1351 size_t bytes_read = objfile->ReadSectionData (section_sp.get(), 1352 addr.GetOffset(), 1353 dst, 1354 dst_len); 1355 if (bytes_read > 0) 1356 return bytes_read; 1357 else 1358 error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString()); 1359 } 1360 else 1361 error.SetErrorString("address isn't from a object file"); 1362 } 1363 else 1364 error.SetErrorString("address isn't in a module"); 1365 } 1366 else 1367 error.SetErrorString("address doesn't contain a section that points to a section in a object file"); 1368 1369 return 0; 1370 } 1371 1372 size_t 1373 Target::ReadMemory (const Address& addr, 1374 bool prefer_file_cache, 1375 void *dst, 1376 size_t dst_len, 1377 Error &error, 1378 lldb::addr_t *load_addr_ptr) 1379 { 1380 error.Clear(); 1381 1382 // if we end up reading this from process memory, we will fill this 1383 // with the actual load address 1384 if (load_addr_ptr) 1385 *load_addr_ptr = LLDB_INVALID_ADDRESS; 1386 1387 size_t bytes_read = 0; 1388 1389 addr_t load_addr = LLDB_INVALID_ADDRESS; 1390 addr_t file_addr = LLDB_INVALID_ADDRESS; 1391 Address resolved_addr; 1392 if (!addr.IsSectionOffset()) 1393 { 1394 SectionLoadList §ion_load_list = GetSectionLoadList(); 1395 if (section_load_list.IsEmpty()) 1396 { 1397 // No sections are loaded, so we must assume we are not running 1398 // yet and anything we are given is a file address. 1399 file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address 1400 m_images.ResolveFileAddress (file_addr, resolved_addr); 1401 } 1402 else 1403 { 1404 // We have at least one section loaded. This can be because 1405 // we have manually loaded some sections with "target modules load ..." 1406 // or because we have have a live process that has sections loaded 1407 // through the dynamic loader 1408 load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address 1409 section_load_list.ResolveLoadAddress (load_addr, resolved_addr); 1410 } 1411 } 1412 if (!resolved_addr.IsValid()) 1413 resolved_addr = addr; 1414 1415 1416 if (prefer_file_cache) 1417 { 1418 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1419 if (bytes_read > 0) 1420 return bytes_read; 1421 } 1422 1423 if (ProcessIsValid()) 1424 { 1425 if (load_addr == LLDB_INVALID_ADDRESS) 1426 load_addr = resolved_addr.GetLoadAddress (this); 1427 1428 if (load_addr == LLDB_INVALID_ADDRESS) 1429 { 1430 ModuleSP addr_module_sp (resolved_addr.GetModule()); 1431 if (addr_module_sp && addr_module_sp->GetFileSpec()) 1432 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded", 1433 addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"), 1434 resolved_addr.GetFileAddress(), 1435 addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknonw>")); 1436 else 1437 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress()); 1438 } 1439 else 1440 { 1441 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error); 1442 if (bytes_read != dst_len) 1443 { 1444 if (error.Success()) 1445 { 1446 if (bytes_read == 0) 1447 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr); 1448 else 1449 error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr); 1450 } 1451 } 1452 if (bytes_read) 1453 { 1454 if (load_addr_ptr) 1455 *load_addr_ptr = load_addr; 1456 return bytes_read; 1457 } 1458 // If the address is not section offset we have an address that 1459 // doesn't resolve to any address in any currently loaded shared 1460 // libraries and we failed to read memory so there isn't anything 1461 // more we can do. If it is section offset, we might be able to 1462 // read cached memory from the object file. 1463 if (!resolved_addr.IsSectionOffset()) 1464 return 0; 1465 } 1466 } 1467 1468 if (!prefer_file_cache && resolved_addr.IsSectionOffset()) 1469 { 1470 // If we didn't already try and read from the object file cache, then 1471 // try it after failing to read from the process. 1472 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1473 } 1474 return 0; 1475 } 1476 1477 size_t 1478 Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error) 1479 { 1480 char buf[256]; 1481 out_str.clear(); 1482 addr_t curr_addr = addr.GetLoadAddress(this); 1483 Address address(addr); 1484 while (1) 1485 { 1486 size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error); 1487 if (length == 0) 1488 break; 1489 out_str.append(buf, length); 1490 // If we got "length - 1" bytes, we didn't get the whole C string, we 1491 // need to read some more characters 1492 if (length == sizeof(buf) - 1) 1493 curr_addr += length; 1494 else 1495 break; 1496 address = Address(curr_addr); 1497 } 1498 return out_str.size(); 1499 } 1500 1501 1502 size_t 1503 Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error) 1504 { 1505 size_t total_cstr_len = 0; 1506 if (dst && dst_max_len) 1507 { 1508 result_error.Clear(); 1509 // NULL out everything just to be safe 1510 memset (dst, 0, dst_max_len); 1511 Error error; 1512 addr_t curr_addr = addr.GetLoadAddress(this); 1513 Address address(addr); 1514 1515 // We could call m_process_sp->GetMemoryCacheLineSize() but I don't 1516 // think this really needs to be tied to the memory cache subsystem's 1517 // cache line size, so leave this as a fixed constant. 1518 const size_t cache_line_size = 512; 1519 1520 size_t bytes_left = dst_max_len - 1; 1521 char *curr_dst = dst; 1522 1523 while (bytes_left > 0) 1524 { 1525 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size); 1526 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left); 1527 size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error); 1528 1529 if (bytes_read == 0) 1530 { 1531 result_error = error; 1532 dst[total_cstr_len] = '\0'; 1533 break; 1534 } 1535 const size_t len = strlen(curr_dst); 1536 1537 total_cstr_len += len; 1538 1539 if (len < bytes_to_read) 1540 break; 1541 1542 curr_dst += bytes_read; 1543 curr_addr += bytes_read; 1544 bytes_left -= bytes_read; 1545 address = Address(curr_addr); 1546 } 1547 } 1548 else 1549 { 1550 if (dst == NULL) 1551 result_error.SetErrorString("invalid arguments"); 1552 else 1553 result_error.Clear(); 1554 } 1555 return total_cstr_len; 1556 } 1557 1558 size_t 1559 Target::ReadScalarIntegerFromMemory (const Address& addr, 1560 bool prefer_file_cache, 1561 uint32_t byte_size, 1562 bool is_signed, 1563 Scalar &scalar, 1564 Error &error) 1565 { 1566 uint64_t uval; 1567 1568 if (byte_size <= sizeof(uval)) 1569 { 1570 size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error); 1571 if (bytes_read == byte_size) 1572 { 1573 DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize()); 1574 lldb::offset_t offset = 0; 1575 if (byte_size <= 4) 1576 scalar = data.GetMaxU32 (&offset, byte_size); 1577 else 1578 scalar = data.GetMaxU64 (&offset, byte_size); 1579 1580 if (is_signed) 1581 scalar.SignExtend(byte_size * 8); 1582 return bytes_read; 1583 } 1584 } 1585 else 1586 { 1587 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size); 1588 } 1589 return 0; 1590 } 1591 1592 uint64_t 1593 Target::ReadUnsignedIntegerFromMemory (const Address& addr, 1594 bool prefer_file_cache, 1595 size_t integer_byte_size, 1596 uint64_t fail_value, 1597 Error &error) 1598 { 1599 Scalar scalar; 1600 if (ReadScalarIntegerFromMemory (addr, 1601 prefer_file_cache, 1602 integer_byte_size, 1603 false, 1604 scalar, 1605 error)) 1606 return scalar.ULongLong(fail_value); 1607 return fail_value; 1608 } 1609 1610 bool 1611 Target::ReadPointerFromMemory (const Address& addr, 1612 bool prefer_file_cache, 1613 Error &error, 1614 Address &pointer_addr) 1615 { 1616 Scalar scalar; 1617 if (ReadScalarIntegerFromMemory (addr, 1618 prefer_file_cache, 1619 m_arch.GetAddressByteSize(), 1620 false, 1621 scalar, 1622 error)) 1623 { 1624 addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS); 1625 if (pointer_vm_addr != LLDB_INVALID_ADDRESS) 1626 { 1627 SectionLoadList §ion_load_list = GetSectionLoadList(); 1628 if (section_load_list.IsEmpty()) 1629 { 1630 // No sections are loaded, so we must assume we are not running 1631 // yet and anything we are given is a file address. 1632 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr); 1633 } 1634 else 1635 { 1636 // We have at least one section loaded. This can be because 1637 // we have manually loaded some sections with "target modules load ..." 1638 // or because we have have a live process that has sections loaded 1639 // through the dynamic loader 1640 section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr); 1641 } 1642 // We weren't able to resolve the pointer value, so just return 1643 // an address with no section 1644 if (!pointer_addr.IsValid()) 1645 pointer_addr.SetOffset (pointer_vm_addr); 1646 return true; 1647 1648 } 1649 } 1650 return false; 1651 } 1652 1653 ModuleSP 1654 Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr) 1655 { 1656 ModuleSP module_sp; 1657 1658 Error error; 1659 1660 // First see if we already have this module in our module list. If we do, then we're done, we don't need 1661 // to consult the shared modules list. But only do this if we are passed a UUID. 1662 1663 if (module_spec.GetUUID().IsValid()) 1664 module_sp = m_images.FindFirstModule(module_spec); 1665 1666 if (!module_sp) 1667 { 1668 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library 1669 bool did_create_module = false; 1670 1671 // If there are image search path entries, try to use them first to acquire a suitable image. 1672 if (m_image_search_paths.GetSize()) 1673 { 1674 ModuleSpec transformed_spec (module_spec); 1675 if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory())) 1676 { 1677 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename(); 1678 error = ModuleList::GetSharedModule (transformed_spec, 1679 module_sp, 1680 &GetExecutableSearchPaths(), 1681 &old_module_sp, 1682 &did_create_module); 1683 } 1684 } 1685 1686 if (!module_sp) 1687 { 1688 // If we have a UUID, we can check our global shared module list in case 1689 // we already have it. If we don't have a valid UUID, then we can't since 1690 // the path in "module_spec" will be a platform path, and we will need to 1691 // let the platform find that file. For example, we could be asking for 1692 // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick 1693 // the local copy of "/usr/lib/dyld" since our platform could be a remote 1694 // platform that has its own "/usr/lib/dyld" in an SDK or in a local file 1695 // cache. 1696 if (module_spec.GetUUID().IsValid()) 1697 { 1698 // We have a UUID, it is OK to check the global module list... 1699 error = ModuleList::GetSharedModule (module_spec, 1700 module_sp, 1701 &GetExecutableSearchPaths(), 1702 &old_module_sp, 1703 &did_create_module); 1704 } 1705 1706 if (!module_sp) 1707 { 1708 // The platform is responsible for finding and caching an appropriate 1709 // module in the shared module cache. 1710 if (m_platform_sp) 1711 { 1712 error = m_platform_sp->GetSharedModule (module_spec, 1713 m_process_sp.get(), 1714 module_sp, 1715 &GetExecutableSearchPaths(), 1716 &old_module_sp, 1717 &did_create_module); 1718 } 1719 else 1720 { 1721 error.SetErrorString("no platform is currently set"); 1722 } 1723 } 1724 } 1725 1726 // We found a module that wasn't in our target list. Let's make sure that there wasn't an equivalent 1727 // module in the list already, and if there was, let's remove it. 1728 if (module_sp) 1729 { 1730 ObjectFile *objfile = module_sp->GetObjectFile(); 1731 if (objfile) 1732 { 1733 switch (objfile->GetType()) 1734 { 1735 case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of a program's execution state 1736 case ObjectFile::eTypeExecutable: /// A normal executable 1737 case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable 1738 case ObjectFile::eTypeObjectFile: /// An intermediate object file 1739 case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution 1740 break; 1741 case ObjectFile::eTypeDebugInfo: /// An object file that contains only debug information 1742 if (error_ptr) 1743 error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable"); 1744 return ModuleSP(); 1745 case ObjectFile::eTypeStubLibrary: /// A library that can be linked against but not used for execution 1746 if (error_ptr) 1747 error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable"); 1748 return ModuleSP(); 1749 default: 1750 if (error_ptr) 1751 error_ptr->SetErrorString("unsupported file type, please specify an executable"); 1752 return ModuleSP(); 1753 } 1754 // GetSharedModule is not guaranteed to find the old shared module, for instance 1755 // in the common case where you pass in the UUID, it is only going to find the one 1756 // module matching the UUID. In fact, it has no good way to know what the "old module" 1757 // relevant to this target is, since there might be many copies of a module with this file spec 1758 // in various running debug sessions, but only one of them will belong to this target. 1759 // So let's remove the UUID from the module list, and look in the target's module list. 1760 // Only do this if there is SOMETHING else in the module spec... 1761 if (!old_module_sp) 1762 { 1763 if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty()) 1764 { 1765 ModuleSpec module_spec_copy(module_spec.GetFileSpec()); 1766 module_spec_copy.GetUUID().Clear(); 1767 1768 ModuleList found_modules; 1769 size_t num_found = m_images.FindModules (module_spec_copy, found_modules); 1770 if (num_found == 1) 1771 { 1772 old_module_sp = found_modules.GetModuleAtIndex(0); 1773 } 1774 } 1775 } 1776 1777 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32) 1778 { 1779 m_images.ReplaceModule(old_module_sp, module_sp); 1780 Module *old_module_ptr = old_module_sp.get(); 1781 old_module_sp.reset(); 1782 ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr); 1783 } 1784 else 1785 m_images.Append(module_sp); 1786 } 1787 else 1788 module_sp.reset(); 1789 } 1790 } 1791 if (error_ptr) 1792 *error_ptr = error; 1793 return module_sp; 1794 } 1795 1796 1797 TargetSP 1798 Target::CalculateTarget () 1799 { 1800 return shared_from_this(); 1801 } 1802 1803 ProcessSP 1804 Target::CalculateProcess () 1805 { 1806 return ProcessSP(); 1807 } 1808 1809 ThreadSP 1810 Target::CalculateThread () 1811 { 1812 return ThreadSP(); 1813 } 1814 1815 StackFrameSP 1816 Target::CalculateStackFrame () 1817 { 1818 return StackFrameSP(); 1819 } 1820 1821 void 1822 Target::CalculateExecutionContext (ExecutionContext &exe_ctx) 1823 { 1824 exe_ctx.Clear(); 1825 exe_ctx.SetTargetPtr(this); 1826 } 1827 1828 PathMappingList & 1829 Target::GetImageSearchPathList () 1830 { 1831 return m_image_search_paths; 1832 } 1833 1834 void 1835 Target::ImageSearchPathsChanged 1836 ( 1837 const PathMappingList &path_list, 1838 void *baton 1839 ) 1840 { 1841 Target *target = (Target *)baton; 1842 ModuleSP exe_module_sp (target->GetExecutableModule()); 1843 if (exe_module_sp) 1844 target->SetExecutableModule (exe_module_sp, true); 1845 } 1846 1847 ClangASTContext * 1848 Target::GetScratchClangASTContext(bool create_on_demand) 1849 { 1850 // Now see if we know the target triple, and if so, create our scratch AST context: 1851 if (m_scratch_ast_context_ap.get() == NULL && m_arch.IsValid() && create_on_demand) 1852 { 1853 m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch.GetTriple().str().c_str())); 1854 m_scratch_ast_source_ap.reset (new ClangASTSource(shared_from_this())); 1855 m_scratch_ast_source_ap->InstallASTContext(m_scratch_ast_context_ap->getASTContext()); 1856 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(m_scratch_ast_source_ap->CreateProxy()); 1857 m_scratch_ast_context_ap->SetExternalSource(proxy_ast_source); 1858 } 1859 return m_scratch_ast_context_ap.get(); 1860 } 1861 1862 ClangASTImporter * 1863 Target::GetClangASTImporter() 1864 { 1865 ClangASTImporter *ast_importer = m_ast_importer_ap.get(); 1866 1867 if (!ast_importer) 1868 { 1869 ast_importer = new ClangASTImporter(); 1870 m_ast_importer_ap.reset(ast_importer); 1871 } 1872 1873 return ast_importer; 1874 } 1875 1876 void 1877 Target::SettingsInitialize () 1878 { 1879 Process::SettingsInitialize (); 1880 } 1881 1882 void 1883 Target::SettingsTerminate () 1884 { 1885 Process::SettingsTerminate (); 1886 } 1887 1888 FileSpecList 1889 Target::GetDefaultExecutableSearchPaths () 1890 { 1891 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1892 if (properties_sp) 1893 return properties_sp->GetExecutableSearchPaths(); 1894 return FileSpecList(); 1895 } 1896 1897 FileSpecList 1898 Target::GetDefaultDebugFileSearchPaths () 1899 { 1900 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1901 if (properties_sp) 1902 return properties_sp->GetDebugFileSearchPaths(); 1903 return FileSpecList(); 1904 } 1905 1906 FileSpecList 1907 Target::GetDefaultClangModuleSearchPaths () 1908 { 1909 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1910 if (properties_sp) 1911 return properties_sp->GetClangModuleSearchPaths(); 1912 return FileSpecList(); 1913 } 1914 1915 ArchSpec 1916 Target::GetDefaultArchitecture () 1917 { 1918 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1919 if (properties_sp) 1920 return properties_sp->GetDefaultArchitecture(); 1921 return ArchSpec(); 1922 } 1923 1924 void 1925 Target::SetDefaultArchitecture (const ArchSpec &arch) 1926 { 1927 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1928 if (properties_sp) 1929 { 1930 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str()); 1931 return properties_sp->SetDefaultArchitecture(arch); 1932 } 1933 } 1934 1935 Target * 1936 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) 1937 { 1938 // The target can either exist in the "process" of ExecutionContext, or in 1939 // the "target_sp" member of SymbolContext. This accessor helper function 1940 // will get the target from one of these locations. 1941 1942 Target *target = NULL; 1943 if (sc_ptr != NULL) 1944 target = sc_ptr->target_sp.get(); 1945 if (target == NULL && exe_ctx_ptr) 1946 target = exe_ctx_ptr->GetTargetPtr(); 1947 return target; 1948 } 1949 1950 ExpressionResults 1951 Target::EvaluateExpression 1952 ( 1953 const char *expr_cstr, 1954 StackFrame *frame, 1955 lldb::ValueObjectSP &result_valobj_sp, 1956 const EvaluateExpressionOptions& options 1957 ) 1958 { 1959 result_valobj_sp.reset(); 1960 1961 ExpressionResults execution_results = eExpressionSetupError; 1962 1963 if (expr_cstr == NULL || expr_cstr[0] == '\0') 1964 return execution_results; 1965 1966 // We shouldn't run stop hooks in expressions. 1967 // Be sure to reset this if you return anywhere within this function. 1968 bool old_suppress_value = m_suppress_stop_hooks; 1969 m_suppress_stop_hooks = true; 1970 1971 ExecutionContext exe_ctx; 1972 1973 if (frame) 1974 { 1975 frame->CalculateExecutionContext(exe_ctx); 1976 } 1977 else if (m_process_sp) 1978 { 1979 m_process_sp->CalculateExecutionContext(exe_ctx); 1980 } 1981 else 1982 { 1983 CalculateExecutionContext(exe_ctx); 1984 } 1985 1986 // Make sure we aren't just trying to see the value of a persistent 1987 // variable (something like "$0") 1988 lldb::ClangExpressionVariableSP persistent_var_sp; 1989 // Only check for persistent variables the expression starts with a '$' 1990 if (expr_cstr[0] == '$') 1991 persistent_var_sp = m_persistent_variables->GetVariable (expr_cstr); 1992 1993 if (persistent_var_sp) 1994 { 1995 result_valobj_sp = persistent_var_sp->GetValueObject (); 1996 execution_results = eExpressionCompleted; 1997 } 1998 else 1999 { 2000 const char *prefix = GetExpressionPrefixContentsAsCString(); 2001 Error error; 2002 execution_results = ClangUserExpression::Evaluate (exe_ctx, 2003 options, 2004 expr_cstr, 2005 prefix, 2006 result_valobj_sp, 2007 error); 2008 } 2009 2010 m_suppress_stop_hooks = old_suppress_value; 2011 2012 return execution_results; 2013 } 2014 2015 ClangPersistentVariables & 2016 Target::GetPersistentVariables() 2017 { 2018 return *m_persistent_variables; 2019 } 2020 2021 lldb::addr_t 2022 Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 2023 { 2024 addr_t code_addr = load_addr; 2025 switch (m_arch.GetMachine()) 2026 { 2027 case llvm::Triple::arm: 2028 case llvm::Triple::thumb: 2029 switch (addr_class) 2030 { 2031 case eAddressClassData: 2032 case eAddressClassDebug: 2033 return LLDB_INVALID_ADDRESS; 2034 2035 case eAddressClassUnknown: 2036 case eAddressClassInvalid: 2037 case eAddressClassCode: 2038 case eAddressClassCodeAlternateISA: 2039 case eAddressClassRuntime: 2040 // Check if bit zero it no set? 2041 if ((code_addr & 1ull) == 0) 2042 { 2043 // Bit zero isn't set, check if the address is a multiple of 2? 2044 if (code_addr & 2ull) 2045 { 2046 // The address is a multiple of 2 so it must be thumb, set bit zero 2047 code_addr |= 1ull; 2048 } 2049 else if (addr_class == eAddressClassCodeAlternateISA) 2050 { 2051 // We checked the address and the address claims to be the alternate ISA 2052 // which means thumb, so set bit zero. 2053 code_addr |= 1ull; 2054 } 2055 } 2056 break; 2057 } 2058 break; 2059 2060 default: 2061 break; 2062 } 2063 return code_addr; 2064 } 2065 2066 lldb::addr_t 2067 Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 2068 { 2069 addr_t opcode_addr = load_addr; 2070 switch (m_arch.GetMachine()) 2071 { 2072 case llvm::Triple::arm: 2073 case llvm::Triple::thumb: 2074 switch (addr_class) 2075 { 2076 case eAddressClassData: 2077 case eAddressClassDebug: 2078 return LLDB_INVALID_ADDRESS; 2079 2080 case eAddressClassInvalid: 2081 case eAddressClassUnknown: 2082 case eAddressClassCode: 2083 case eAddressClassCodeAlternateISA: 2084 case eAddressClassRuntime: 2085 opcode_addr &= ~(1ull); 2086 break; 2087 } 2088 break; 2089 2090 default: 2091 break; 2092 } 2093 return opcode_addr; 2094 } 2095 2096 SourceManager & 2097 Target::GetSourceManager () 2098 { 2099 if (m_source_manager_ap.get() == NULL) 2100 m_source_manager_ap.reset (new SourceManager(shared_from_this())); 2101 return *m_source_manager_ap; 2102 } 2103 2104 ClangModulesDeclVendor * 2105 Target::GetClangModulesDeclVendor () 2106 { 2107 static Mutex s_clang_modules_decl_vendor_mutex; // If this is contended we can make it per-target 2108 2109 { 2110 Mutex::Locker clang_modules_decl_vendor_locker(s_clang_modules_decl_vendor_mutex); 2111 2112 if (!m_clang_modules_decl_vendor_ap) 2113 { 2114 m_clang_modules_decl_vendor_ap.reset(ClangModulesDeclVendor::Create(*this)); 2115 } 2116 } 2117 2118 return m_clang_modules_decl_vendor_ap.get(); 2119 } 2120 2121 Target::StopHookSP 2122 Target::CreateStopHook () 2123 { 2124 lldb::user_id_t new_uid = ++m_stop_hook_next_id; 2125 Target::StopHookSP stop_hook_sp (new StopHook(shared_from_this(), new_uid)); 2126 m_stop_hooks[new_uid] = stop_hook_sp; 2127 return stop_hook_sp; 2128 } 2129 2130 bool 2131 Target::RemoveStopHookByID (lldb::user_id_t user_id) 2132 { 2133 size_t num_removed; 2134 num_removed = m_stop_hooks.erase (user_id); 2135 if (num_removed == 0) 2136 return false; 2137 else 2138 return true; 2139 } 2140 2141 void 2142 Target::RemoveAllStopHooks () 2143 { 2144 m_stop_hooks.clear(); 2145 } 2146 2147 Target::StopHookSP 2148 Target::GetStopHookByID (lldb::user_id_t user_id) 2149 { 2150 StopHookSP found_hook; 2151 2152 StopHookCollection::iterator specified_hook_iter; 2153 specified_hook_iter = m_stop_hooks.find (user_id); 2154 if (specified_hook_iter != m_stop_hooks.end()) 2155 found_hook = (*specified_hook_iter).second; 2156 return found_hook; 2157 } 2158 2159 bool 2160 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state) 2161 { 2162 StopHookCollection::iterator specified_hook_iter; 2163 specified_hook_iter = m_stop_hooks.find (user_id); 2164 if (specified_hook_iter == m_stop_hooks.end()) 2165 return false; 2166 2167 (*specified_hook_iter).second->SetIsActive (active_state); 2168 return true; 2169 } 2170 2171 void 2172 Target::SetAllStopHooksActiveState (bool active_state) 2173 { 2174 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 2175 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2176 { 2177 (*pos).second->SetIsActive (active_state); 2178 } 2179 } 2180 2181 void 2182 Target::RunStopHooks () 2183 { 2184 if (m_suppress_stop_hooks) 2185 return; 2186 2187 if (!m_process_sp) 2188 return; 2189 2190 // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression 2191 // since in that case we do not want to run the stop-hooks 2192 if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression()) 2193 return; 2194 2195 if (m_stop_hooks.empty()) 2196 return; 2197 2198 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 2199 2200 // If there aren't any active stop hooks, don't bother either: 2201 bool any_active_hooks = false; 2202 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2203 { 2204 if ((*pos).second->IsActive()) 2205 { 2206 any_active_hooks = true; 2207 break; 2208 } 2209 } 2210 if (!any_active_hooks) 2211 return; 2212 2213 CommandReturnObject result; 2214 2215 std::vector<ExecutionContext> exc_ctx_with_reasons; 2216 std::vector<SymbolContext> sym_ctx_with_reasons; 2217 2218 ThreadList &cur_threadlist = m_process_sp->GetThreadList(); 2219 size_t num_threads = cur_threadlist.GetSize(); 2220 for (size_t i = 0; i < num_threads; i++) 2221 { 2222 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i); 2223 if (cur_thread_sp->ThreadStoppedForAReason()) 2224 { 2225 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0); 2226 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get())); 2227 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything)); 2228 } 2229 } 2230 2231 // If no threads stopped for a reason, don't run the stop-hooks. 2232 size_t num_exe_ctx = exc_ctx_with_reasons.size(); 2233 if (num_exe_ctx == 0) 2234 return; 2235 2236 result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream()); 2237 result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream()); 2238 2239 bool keep_going = true; 2240 bool hooks_ran = false; 2241 bool print_hook_header; 2242 bool print_thread_header; 2243 2244 if (num_exe_ctx == 1) 2245 print_thread_header = false; 2246 else 2247 print_thread_header = true; 2248 2249 if (m_stop_hooks.size() == 1) 2250 print_hook_header = false; 2251 else 2252 print_hook_header = true; 2253 2254 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) 2255 { 2256 // result.Clear(); 2257 StopHookSP cur_hook_sp = (*pos).second; 2258 if (!cur_hook_sp->IsActive()) 2259 continue; 2260 2261 bool any_thread_matched = false; 2262 for (size_t i = 0; keep_going && i < num_exe_ctx; i++) 2263 { 2264 if ((cur_hook_sp->GetSpecifier () == NULL 2265 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i])) 2266 && (cur_hook_sp->GetThreadSpecifier() == NULL 2267 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef()))) 2268 { 2269 if (!hooks_ran) 2270 { 2271 hooks_ran = true; 2272 } 2273 if (print_hook_header && !any_thread_matched) 2274 { 2275 const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ? 2276 cur_hook_sp->GetCommands().GetStringAtIndex(0) : 2277 NULL); 2278 if (cmd) 2279 result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd); 2280 else 2281 result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID()); 2282 any_thread_matched = true; 2283 } 2284 2285 if (print_thread_header) 2286 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID()); 2287 2288 CommandInterpreterRunOptions options; 2289 options.SetStopOnContinue (true); 2290 options.SetStopOnError (true); 2291 options.SetEchoCommands (false); 2292 options.SetPrintResults (true); 2293 options.SetAddToHistory (false); 2294 2295 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(), 2296 &exc_ctx_with_reasons[i], 2297 options, 2298 result); 2299 2300 // If the command started the target going again, we should bag out of 2301 // running the stop hooks. 2302 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) || 2303 (result.GetStatus() == eReturnStatusSuccessContinuingResult)) 2304 { 2305 result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID()); 2306 keep_going = false; 2307 } 2308 } 2309 } 2310 } 2311 2312 result.GetImmediateOutputStream()->Flush(); 2313 result.GetImmediateErrorStream()->Flush(); 2314 } 2315 2316 const TargetPropertiesSP & 2317 Target::GetGlobalProperties() 2318 { 2319 static TargetPropertiesSP g_settings_sp; 2320 if (!g_settings_sp) 2321 { 2322 g_settings_sp.reset (new TargetProperties (NULL)); 2323 } 2324 return g_settings_sp; 2325 } 2326 2327 Error 2328 Target::Install (ProcessLaunchInfo *launch_info) 2329 { 2330 Error error; 2331 PlatformSP platform_sp (GetPlatform()); 2332 if (platform_sp) 2333 { 2334 if (platform_sp->IsRemote()) 2335 { 2336 if (platform_sp->IsConnected()) 2337 { 2338 // Install all files that have an install path, and always install the 2339 // main executable when connected to a remote platform 2340 const ModuleList& modules = GetImages(); 2341 const size_t num_images = modules.GetSize(); 2342 for (size_t idx = 0; idx < num_images; ++idx) 2343 { 2344 const bool is_main_executable = idx == 0; 2345 ModuleSP module_sp(modules.GetModuleAtIndex(idx)); 2346 if (module_sp) 2347 { 2348 FileSpec local_file (module_sp->GetFileSpec()); 2349 if (local_file) 2350 { 2351 FileSpec remote_file (module_sp->GetRemoteInstallFileSpec()); 2352 if (!remote_file) 2353 { 2354 if (is_main_executable) // TODO: add setting for always installing main executable??? 2355 { 2356 // Always install the main executable 2357 remote_file.GetDirectory() = platform_sp->GetWorkingDirectory(); 2358 remote_file.GetFilename() = module_sp->GetFileSpec().GetFilename(); 2359 } 2360 } 2361 if (remote_file) 2362 { 2363 error = platform_sp->Install(local_file, remote_file); 2364 if (error.Success()) 2365 { 2366 module_sp->SetPlatformFileSpec(remote_file); 2367 if (is_main_executable) 2368 { 2369 if (launch_info) 2370 launch_info->SetExecutableFile(remote_file, false); 2371 } 2372 } 2373 else 2374 break; 2375 } 2376 } 2377 } 2378 } 2379 } 2380 } 2381 } 2382 return error; 2383 } 2384 2385 bool 2386 Target::ResolveLoadAddress (addr_t load_addr, Address &so_addr, uint32_t stop_id) 2387 { 2388 return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr); 2389 } 2390 2391 bool 2392 Target::ResolveFileAddress (lldb::addr_t file_addr, Address &resolved_addr) 2393 { 2394 return m_images.ResolveFileAddress(file_addr, resolved_addr); 2395 } 2396 2397 bool 2398 Target::SetSectionLoadAddress (const SectionSP §ion_sp, addr_t new_section_load_addr, bool warn_multiple) 2399 { 2400 const addr_t old_section_load_addr = m_section_load_history.GetSectionLoadAddress (SectionLoadHistory::eStopIDNow, section_sp); 2401 if (old_section_load_addr != new_section_load_addr) 2402 { 2403 uint32_t stop_id = 0; 2404 ProcessSP process_sp(GetProcessSP()); 2405 if (process_sp) 2406 stop_id = process_sp->GetStopID(); 2407 else 2408 stop_id = m_section_load_history.GetLastStopID(); 2409 if (m_section_load_history.SetSectionLoadAddress (stop_id, section_sp, new_section_load_addr, warn_multiple)) 2410 return true; // Return true if the section load address was changed... 2411 } 2412 return false; // Return false to indicate nothing changed 2413 2414 } 2415 2416 size_t 2417 Target::UnloadModuleSections (const ModuleList &module_list) 2418 { 2419 size_t section_unload_count = 0; 2420 size_t num_modules = module_list.GetSize(); 2421 for (size_t i=0; i<num_modules; ++i) 2422 { 2423 section_unload_count += UnloadModuleSections (module_list.GetModuleAtIndex(i)); 2424 } 2425 return section_unload_count; 2426 } 2427 2428 size_t 2429 Target::UnloadModuleSections (const lldb::ModuleSP &module_sp) 2430 { 2431 uint32_t stop_id = 0; 2432 ProcessSP process_sp(GetProcessSP()); 2433 if (process_sp) 2434 stop_id = process_sp->GetStopID(); 2435 else 2436 stop_id = m_section_load_history.GetLastStopID(); 2437 SectionList *sections = module_sp->GetSectionList(); 2438 size_t section_unload_count = 0; 2439 if (sections) 2440 { 2441 const uint32_t num_sections = sections->GetNumSections(0); 2442 for (uint32_t i = 0; i < num_sections; ++i) 2443 { 2444 section_unload_count += m_section_load_history.SetSectionUnloaded(stop_id, sections->GetSectionAtIndex(i)); 2445 } 2446 } 2447 return section_unload_count; 2448 } 2449 2450 bool 2451 Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp) 2452 { 2453 uint32_t stop_id = 0; 2454 ProcessSP process_sp(GetProcessSP()); 2455 if (process_sp) 2456 stop_id = process_sp->GetStopID(); 2457 else 2458 stop_id = m_section_load_history.GetLastStopID(); 2459 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp); 2460 } 2461 2462 bool 2463 Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp, addr_t load_addr) 2464 { 2465 uint32_t stop_id = 0; 2466 ProcessSP process_sp(GetProcessSP()); 2467 if (process_sp) 2468 stop_id = process_sp->GetStopID(); 2469 else 2470 stop_id = m_section_load_history.GetLastStopID(); 2471 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp, load_addr); 2472 } 2473 2474 void 2475 Target::ClearAllLoadedSections () 2476 { 2477 m_section_load_history.Clear(); 2478 } 2479 2480 2481 Error 2482 Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream) 2483 { 2484 Error error; 2485 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 2486 2487 if (log) 2488 log->Printf ("Target::%s() called for %s", __FUNCTION__, launch_info.GetExecutableFile().GetPath().c_str ()); 2489 2490 StateType state = eStateInvalid; 2491 2492 // Scope to temporarily get the process state in case someone has manually 2493 // remotely connected already to a process and we can skip the platform 2494 // launching. 2495 { 2496 ProcessSP process_sp (GetProcessSP()); 2497 2498 if (process_sp) 2499 { 2500 state = process_sp->GetState(); 2501 if (log) 2502 log->Printf ("Target::%s the process exists, and its current state is %s", __FUNCTION__, StateAsCString (state)); 2503 } 2504 else 2505 { 2506 if (log) 2507 log->Printf ("Target::%s the process instance doesn't currently exist.", __FUNCTION__); 2508 } 2509 } 2510 2511 launch_info.GetFlags().Set (eLaunchFlagDebug); 2512 2513 // Get the value of synchronous execution here. If you wait till after you have started to 2514 // run, then you could have hit a breakpoint, whose command might switch the value, and 2515 // then you'll pick up that incorrect value. 2516 Debugger &debugger = GetDebugger(); 2517 const bool synchronous_execution = debugger.GetCommandInterpreter().GetSynchronous (); 2518 2519 PlatformSP platform_sp (GetPlatform()); 2520 2521 // Finalize the file actions, and if none were given, default to opening 2522 // up a pseudo terminal 2523 const bool default_to_use_pty = platform_sp ? platform_sp->IsHost() : false; 2524 if (log) 2525 log->Printf ("Target::%s have platform=%s, platform_sp->IsHost()=%s, default_to_use_pty=%s", 2526 __FUNCTION__, 2527 platform_sp ? "true" : "false", 2528 platform_sp ? (platform_sp->IsHost () ? "true" : "false") : "n/a", 2529 default_to_use_pty ? "true" : "false"); 2530 2531 launch_info.FinalizeFileActions (this, default_to_use_pty); 2532 2533 if (state == eStateConnected) 2534 { 2535 if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY)) 2536 { 2537 error.SetErrorString("can't launch in tty when launching through a remote connection"); 2538 return error; 2539 } 2540 } 2541 2542 if (!launch_info.GetArchitecture().IsValid()) 2543 launch_info.GetArchitecture() = GetArchitecture(); 2544 2545 // 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. 2546 if (state != eStateConnected && platform_sp && platform_sp->CanDebugProcess ()) 2547 { 2548 if (log) 2549 log->Printf ("Target::%s asking the platform to debug the process", __FUNCTION__); 2550 2551 m_process_sp = GetPlatform()->DebugProcess (launch_info, 2552 debugger, 2553 this, 2554 error); 2555 } 2556 else 2557 { 2558 if (log) 2559 log->Printf ("Target::%s the platform doesn't know how to debug a process, getting a process plugin to do this for us.", __FUNCTION__); 2560 2561 if (state == eStateConnected) 2562 { 2563 assert(m_process_sp); 2564 } 2565 else 2566 { 2567 // Use a Process plugin to construct the process. 2568 const char *plugin_name = launch_info.GetProcessPluginName(); 2569 CreateProcess (launch_info.GetListenerForProcess(debugger), plugin_name, NULL); 2570 } 2571 2572 // Since we didn't have a platform launch the process, launch it here. 2573 if (m_process_sp) 2574 error = m_process_sp->Launch (launch_info); 2575 } 2576 2577 if (!m_process_sp) 2578 { 2579 if (error.Success()) 2580 error.SetErrorString("failed to launch or debug process"); 2581 return error; 2582 } 2583 2584 if (error.Success()) 2585 { 2586 if (synchronous_execution || launch_info.GetFlags().Test(eLaunchFlagStopAtEntry) == false) 2587 { 2588 EventSP event_sp; 2589 ListenerSP hijack_listener_sp (launch_info.GetHijackListener()); 2590 if (!hijack_listener_sp) 2591 { 2592 hijack_listener_sp.reset(new Listener("lldb.Target.Launch.hijack")); 2593 launch_info.SetHijackListener(hijack_listener_sp); 2594 m_process_sp->HijackProcessEvents(hijack_listener_sp.get()); 2595 } 2596 2597 StateType state = m_process_sp->WaitForProcessToStop (NULL, &event_sp, false, hijack_listener_sp.get(), NULL); 2598 2599 if (state == eStateStopped) 2600 { 2601 if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) 2602 { 2603 if (synchronous_execution) 2604 { 2605 error = m_process_sp->PrivateResume(); 2606 if (error.Success()) 2607 { 2608 state = m_process_sp->WaitForProcessToStop (NULL, NULL, true, hijack_listener_sp.get(), stream); 2609 const bool must_be_alive = false; // eStateExited is ok, so this must be false 2610 if (!StateIsStoppedState(state, must_be_alive)) 2611 { 2612 error.SetErrorStringWithFormat("process isn't stopped: %s", StateAsCString(state)); 2613 } 2614 } 2615 } 2616 else 2617 { 2618 m_process_sp->RestoreProcessEvents(); 2619 error = m_process_sp->PrivateResume(); 2620 if (error.Success()) 2621 { 2622 // there is a race condition where this thread will return up the call stack to the main command 2623 // handler and show an (lldb) prompt before HandlePrivateEvent (from PrivateStateThread) has 2624 // a chance to call PushProcessIOHandler() 2625 m_process_sp->SyncIOHandler(2000); 2626 } 2627 } 2628 if (!error.Success()) 2629 { 2630 Error error2; 2631 error2.SetErrorStringWithFormat("process resume at entry point failed: %s", error.AsCString()); 2632 error = error2; 2633 } 2634 } 2635 else 2636 { 2637 assert(synchronous_execution && launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)); 2638 2639 // Target was stopped at entry as was intended. Need to notify the listeners about it. 2640 m_process_sp->RestoreProcessEvents(); 2641 m_process_sp->HandlePrivateEvent(event_sp); 2642 2643 // there is a race condition where this thread will return up the call stack to the main command 2644 // handler and show an (lldb) prompt before HandlePrivateEvent (from PrivateStateThread) has 2645 // a chance to call PushProcessIOHandler() 2646 m_process_sp->SyncIOHandler(2000); 2647 } 2648 } 2649 else if (state == eStateExited) 2650 { 2651 bool with_shell = !!launch_info.GetShell(); 2652 const int exit_status = m_process_sp->GetExitStatus(); 2653 const char *exit_desc = m_process_sp->GetExitDescription(); 2654 #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'." 2655 if (exit_desc && exit_desc[0]) 2656 { 2657 if (with_shell) 2658 error.SetErrorStringWithFormat ("process exited with status %i (%s)" LAUNCH_SHELL_MESSAGE, exit_status, exit_desc); 2659 else 2660 error.SetErrorStringWithFormat ("process exited with status %i (%s)", exit_status, exit_desc); 2661 } 2662 else 2663 { 2664 if (with_shell) 2665 error.SetErrorStringWithFormat ("process exited with status %i" LAUNCH_SHELL_MESSAGE, exit_status); 2666 else 2667 error.SetErrorStringWithFormat ("process exited with status %i", exit_status); 2668 } 2669 } 2670 else 2671 { 2672 error.SetErrorStringWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state)); 2673 } 2674 } 2675 m_process_sp->RestoreProcessEvents (); 2676 } 2677 else 2678 { 2679 Error error2; 2680 error2.SetErrorStringWithFormat ("process launch failed: %s", error.AsCString()); 2681 error = error2; 2682 } 2683 return error; 2684 } 2685 2686 Error 2687 Target::Attach (ProcessAttachInfo &attach_info, Stream *stream) 2688 { 2689 auto state = eStateInvalid; 2690 auto process_sp = GetProcessSP (); 2691 if (process_sp) 2692 { 2693 state = process_sp->GetState (); 2694 if (process_sp->IsAlive () && state != eStateConnected) 2695 { 2696 if (state == eStateAttaching) 2697 return Error ("process attach is in progress"); 2698 return Error ("a process is already being debugged"); 2699 } 2700 } 2701 2702 ListenerSP hijack_listener_sp (new Listener ("lldb.Target.Attach.attach.hijack")); 2703 attach_info.SetHijackListener (hijack_listener_sp); 2704 2705 const ModuleSP old_exec_module_sp = GetExecutableModule (); 2706 2707 // If no process info was specified, then use the target executable 2708 // name as the process to attach to by default 2709 if (!attach_info.ProcessInfoSpecified ()) 2710 { 2711 if (old_exec_module_sp) 2712 attach_info.GetExecutableFile ().GetFilename () = old_exec_module_sp->GetPlatformFileSpec ().GetFilename (); 2713 2714 if (!attach_info.ProcessInfoSpecified ()) 2715 { 2716 return Error ("no process specified, create a target with a file, or specify the --pid or --name"); 2717 } 2718 } 2719 2720 const auto platform_sp = GetDebugger ().GetPlatformList ().GetSelectedPlatform (); 2721 2722 Error error; 2723 if (state != eStateConnected && platform_sp != nullptr && platform_sp->CanDebugProcess ()) 2724 { 2725 SetPlatform (platform_sp); 2726 process_sp = platform_sp->Attach (attach_info, GetDebugger (), this, error); 2727 } 2728 else 2729 { 2730 if (state != eStateConnected) 2731 { 2732 const char *plugin_name = attach_info.GetProcessPluginName (); 2733 process_sp = CreateProcess (attach_info.GetListenerForProcess (GetDebugger ()), plugin_name, nullptr); 2734 if (process_sp == nullptr) 2735 { 2736 error.SetErrorStringWithFormat ("failed to create process using plugin %s", (plugin_name) ? plugin_name : "null"); 2737 return error; 2738 } 2739 } 2740 process_sp->HijackProcessEvents (hijack_listener_sp.get ()); 2741 error = process_sp->Attach (attach_info); 2742 } 2743 2744 if (error.Success () && process_sp) 2745 { 2746 state = process_sp->WaitForProcessToStop (nullptr, nullptr, false, attach_info.GetHijackListener ().get (), stream); 2747 process_sp->RestoreProcessEvents (); 2748 2749 if (state != eStateStopped) 2750 { 2751 const char *exit_desc = process_sp->GetExitDescription (); 2752 if (exit_desc) 2753 error.SetErrorStringWithFormat ("attach failed: %s", exit_desc); 2754 else 2755 error.SetErrorString ("attach failed: process did not stop (no such process or permission problem?)"); 2756 process_sp->Destroy (false); 2757 } 2758 } 2759 return error; 2760 } 2761 2762 //-------------------------------------------------------------- 2763 // Target::StopHook 2764 //-------------------------------------------------------------- 2765 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : 2766 UserID (uid), 2767 m_target_sp (target_sp), 2768 m_commands (), 2769 m_specifier_sp (), 2770 m_thread_spec_ap(), 2771 m_active (true) 2772 { 2773 } 2774 2775 Target::StopHook::StopHook (const StopHook &rhs) : 2776 UserID (rhs.GetID()), 2777 m_target_sp (rhs.m_target_sp), 2778 m_commands (rhs.m_commands), 2779 m_specifier_sp (rhs.m_specifier_sp), 2780 m_thread_spec_ap (), 2781 m_active (rhs.m_active) 2782 { 2783 if (rhs.m_thread_spec_ap.get() != NULL) 2784 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); 2785 } 2786 2787 2788 Target::StopHook::~StopHook () 2789 { 2790 } 2791 2792 void 2793 Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier) 2794 { 2795 m_specifier_sp.reset(specifier); 2796 } 2797 2798 void 2799 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) 2800 { 2801 m_thread_spec_ap.reset (specifier); 2802 } 2803 2804 2805 void 2806 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const 2807 { 2808 int indent_level = s->GetIndentLevel(); 2809 2810 s->SetIndentLevel(indent_level + 2); 2811 2812 s->Printf ("Hook: %" PRIu64 "\n", GetID()); 2813 if (m_active) 2814 s->Indent ("State: enabled\n"); 2815 else 2816 s->Indent ("State: disabled\n"); 2817 2818 if (m_specifier_sp) 2819 { 2820 s->Indent(); 2821 s->PutCString ("Specifier:\n"); 2822 s->SetIndentLevel (indent_level + 4); 2823 m_specifier_sp->GetDescription (s, level); 2824 s->SetIndentLevel (indent_level + 2); 2825 } 2826 2827 if (m_thread_spec_ap.get() != NULL) 2828 { 2829 StreamString tmp; 2830 s->Indent("Thread:\n"); 2831 m_thread_spec_ap->GetDescription (&tmp, level); 2832 s->SetIndentLevel (indent_level + 4); 2833 s->Indent (tmp.GetData()); 2834 s->PutCString ("\n"); 2835 s->SetIndentLevel (indent_level + 2); 2836 } 2837 2838 s->Indent ("Commands: \n"); 2839 s->SetIndentLevel (indent_level + 4); 2840 uint32_t num_commands = m_commands.GetSize(); 2841 for (uint32_t i = 0; i < num_commands; i++) 2842 { 2843 s->Indent(m_commands.GetStringAtIndex(i)); 2844 s->PutCString ("\n"); 2845 } 2846 s->SetIndentLevel (indent_level); 2847 } 2848 2849 //-------------------------------------------------------------- 2850 // class TargetProperties 2851 //-------------------------------------------------------------- 2852 2853 OptionEnumValueElement 2854 lldb_private::g_dynamic_value_types[] = 2855 { 2856 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"}, 2857 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."}, 2858 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."}, 2859 { 0, NULL, NULL } 2860 }; 2861 2862 static OptionEnumValueElement 2863 g_inline_breakpoint_enums[] = 2864 { 2865 { 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."}, 2866 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."}, 2867 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."}, 2868 { 0, NULL, NULL } 2869 }; 2870 2871 typedef enum x86DisassemblyFlavor 2872 { 2873 eX86DisFlavorDefault, 2874 eX86DisFlavorIntel, 2875 eX86DisFlavorATT 2876 } x86DisassemblyFlavor; 2877 2878 static OptionEnumValueElement 2879 g_x86_dis_flavor_value_types[] = 2880 { 2881 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."}, 2882 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."}, 2883 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."}, 2884 { 0, NULL, NULL } 2885 }; 2886 2887 static OptionEnumValueElement 2888 g_hex_immediate_style_values[] = 2889 { 2890 { Disassembler::eHexStyleC, "c", "C-style (0xffff)."}, 2891 { Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."}, 2892 { 0, NULL, NULL } 2893 }; 2894 2895 static OptionEnumValueElement 2896 g_load_script_from_sym_file_values[] = 2897 { 2898 { eLoadScriptFromSymFileTrue, "true", "Load debug scripts inside symbol files"}, 2899 { eLoadScriptFromSymFileFalse, "false", "Do not load debug scripts inside symbol files."}, 2900 { eLoadScriptFromSymFileWarn, "warn", "Warn about debug scripts inside symbol files but do not load them."}, 2901 { 0, NULL, NULL } 2902 }; 2903 2904 2905 static OptionEnumValueElement 2906 g_memory_module_load_level_values[] = 2907 { 2908 { eMemoryModuleLoadLevelMinimal, "minimal" , "Load minimal information when loading modules from memory. Currently this setting loads sections only."}, 2909 { eMemoryModuleLoadLevelPartial, "partial" , "Load partial information when loading modules from memory. Currently this setting loads sections and function bounds."}, 2910 { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."}, 2911 { 0, NULL, NULL } 2912 }; 2913 2914 static PropertyDefinition 2915 g_properties[] = 2916 { 2917 { "default-arch" , OptionValue::eTypeArch , true , 0 , NULL, NULL, "Default architecture to choose, when there's a choice." }, 2918 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "Path to a file containing expressions to be prepended to all expressions." }, 2919 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eDynamicDontRunTarget , NULL, g_dynamic_value_types, "Should printed values be shown as their dynamic value." }, 2920 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Should synthetic values be used by default whenever available." }, 2921 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Skip function prologues when setting breakpoints by name." }, 2922 { "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 " 2923 "where it exists on the current system. It consists of an array of duples, the first element of each duple is " 2924 "some part (starting at the root) of the path to the file when it was built, " 2925 "and the second is where the remainder of the original build hierarchy is rooted on the local system. " 2926 "Each element of the array is checked in order and the first one that results in a match wins." }, 2927 { "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." }, 2928 { "debug-file-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , NULL, NULL, "List of directories to be searched when locating debug symbol files." }, 2929 { "clang-module-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , NULL, NULL, "List of directories to be searched when locating modules for Clang." }, 2930 { "auto-import-clang-modules" , OptionValue::eTypeBoolean , false, false , NULL, NULL, "Automatically load Clang modules referred to by the program." }, 2931 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , NULL, NULL, "Maximum number of children to expand in any level of depth." }, 2932 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of characters to show when using %s in summary strings." }, 2933 { "max-memory-read-size" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." }, 2934 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , NULL, NULL, "Consult the platform module avoid list when setting non-module specific breakpoints." }, 2935 { "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." }, 2936 { "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." }, 2937 { "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." }, 2938 { "inherit-env" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Inherit the environment from the process that is running LLDB." }, 2939 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for reading its standard input." }, 2940 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard output." }, 2941 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard error." }, 2942 { "detach-on-error" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "debugserver will detach (rather than killing) a process if it loses connection with lldb." }, 2943 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Disable Address Space Layout Randomization (ASLR)" }, 2944 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , NULL, NULL, "Disable stdin/stdout for process (e.g. for a GUI application)" }, 2945 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsAlways , NULL, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. " 2946 "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. " 2947 "Usually this is limitted to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. " 2948 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. " 2949 "Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers " 2950 "and find that setting breakpoints is slow, then you can change this setting to headers. " 2951 "This setting allows you to control exactly which strategy is used when setting " 2952 "file and line breakpoints." }, 2953 // 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. 2954 { "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." }, 2955 { "use-hex-immediates" , OptionValue::eTypeBoolean , false, true, NULL, NULL, "Show immediates in disassembly as hexadecimal." }, 2956 { "hex-immediate-style" , OptionValue::eTypeEnum , false, Disassembler::eHexStyleC, NULL, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." }, 2957 { "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." }, 2958 { "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." }, 2959 { "memory-module-load-level" , OptionValue::eTypeEnum , false, eMemoryModuleLoadLevelComplete, NULL, g_memory_module_load_level_values, 2960 "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. " 2961 "This setting helps users control how much information gets loaded when loading modules from memory." 2962 "'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). " 2963 "'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). " 2964 "'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). " }, 2965 { "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." }, 2966 { "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." }, 2967 { "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." }, 2968 { NULL , OptionValue::eTypeInvalid , false, 0 , NULL, NULL, NULL } 2969 }; 2970 2971 enum 2972 { 2973 ePropertyDefaultArch, 2974 ePropertyExprPrefix, 2975 ePropertyPreferDynamic, 2976 ePropertyEnableSynthetic, 2977 ePropertySkipPrologue, 2978 ePropertySourceMap, 2979 ePropertyExecutableSearchPaths, 2980 ePropertyDebugFileSearchPaths, 2981 ePropertyClangModuleSearchPaths, 2982 ePropertyAutoImportClangModules, 2983 ePropertyMaxChildrenCount, 2984 ePropertyMaxSummaryLength, 2985 ePropertyMaxMemReadSize, 2986 ePropertyBreakpointUseAvoidList, 2987 ePropertyArg0, 2988 ePropertyRunArgs, 2989 ePropertyEnvVars, 2990 ePropertyInheritEnv, 2991 ePropertyInputPath, 2992 ePropertyOutputPath, 2993 ePropertyErrorPath, 2994 ePropertyDetachOnError, 2995 ePropertyDisableASLR, 2996 ePropertyDisableSTDIO, 2997 ePropertyInlineStrategy, 2998 ePropertyDisassemblyFlavor, 2999 ePropertyUseHexImmediates, 3000 ePropertyHexImmediateStyle, 3001 ePropertyUseFastStepping, 3002 ePropertyLoadScriptFromSymbolFile, 3003 ePropertyMemoryModuleLoadLevel, 3004 ePropertyDisplayExpressionsInCrashlogs, 3005 ePropertyTrapHandlerNames, 3006 ePropertyDisplayRuntimeSupportValues 3007 }; 3008 3009 3010 class TargetOptionValueProperties : public OptionValueProperties 3011 { 3012 public: 3013 TargetOptionValueProperties (const ConstString &name) : 3014 OptionValueProperties (name), 3015 m_target (NULL), 3016 m_got_host_env (false) 3017 { 3018 } 3019 3020 // This constructor is used when creating TargetOptionValueProperties when it 3021 // is part of a new lldb_private::Target instance. It will copy all current 3022 // global property values as needed 3023 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) : 3024 OptionValueProperties(*target_properties_sp->GetValueProperties()), 3025 m_target (target), 3026 m_got_host_env (false) 3027 { 3028 } 3029 3030 virtual const Property * 3031 GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const 3032 { 3033 // When getting the value for a key from the target options, we will always 3034 // try and grab the setting from the current target if there is one. Else we just 3035 // use the one from this instance. 3036 if (idx == ePropertyEnvVars) 3037 GetHostEnvironmentIfNeeded (); 3038 3039 if (exe_ctx) 3040 { 3041 Target *target = exe_ctx->GetTargetPtr(); 3042 if (target) 3043 { 3044 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get()); 3045 if (this != target_properties) 3046 return target_properties->ProtectedGetPropertyAtIndex (idx); 3047 } 3048 } 3049 return ProtectedGetPropertyAtIndex (idx); 3050 } 3051 3052 lldb::TargetSP 3053 GetTargetSP () 3054 { 3055 return m_target->shared_from_this(); 3056 } 3057 3058 protected: 3059 3060 void 3061 GetHostEnvironmentIfNeeded () const 3062 { 3063 if (!m_got_host_env) 3064 { 3065 if (m_target) 3066 { 3067 m_got_host_env = true; 3068 const uint32_t idx = ePropertyInheritEnv; 3069 if (GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0)) 3070 { 3071 PlatformSP platform_sp (m_target->GetPlatform()); 3072 if (platform_sp) 3073 { 3074 StringList env; 3075 if (platform_sp->GetEnvironment(env)) 3076 { 3077 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary (NULL, ePropertyEnvVars); 3078 if (env_dict) 3079 { 3080 const bool can_replace = false; 3081 const size_t envc = env.GetSize(); 3082 for (size_t idx=0; idx<envc; idx++) 3083 { 3084 const char *env_entry = env.GetStringAtIndex (idx); 3085 if (env_entry) 3086 { 3087 const char *equal_pos = ::strchr(env_entry, '='); 3088 ConstString key; 3089 // It is ok to have environment variables with no values 3090 const char *value = NULL; 3091 if (equal_pos) 3092 { 3093 key.SetCStringWithLength(env_entry, equal_pos - env_entry); 3094 if (equal_pos[1]) 3095 value = equal_pos + 1; 3096 } 3097 else 3098 { 3099 key.SetCString(env_entry); 3100 } 3101 // Don't allow existing keys to be replaced with ones we get from the platform environment 3102 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace); 3103 } 3104 } 3105 } 3106 } 3107 } 3108 } 3109 } 3110 } 3111 } 3112 Target *m_target; 3113 mutable bool m_got_host_env; 3114 }; 3115 3116 //---------------------------------------------------------------------- 3117 // TargetProperties 3118 //---------------------------------------------------------------------- 3119 TargetProperties::TargetProperties (Target *target) : 3120 Properties (), 3121 m_launch_info () 3122 { 3123 if (target) 3124 { 3125 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties())); 3126 3127 // Set callbacks to update launch_info whenever "settins set" updated any of these properties 3128 m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this); 3129 m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this); 3130 m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this); 3131 m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this); 3132 m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this); 3133 m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this); 3134 m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this); 3135 m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this); 3136 m_collection_sp->SetValueChangedCallback(ePropertyDisableSTDIO, TargetProperties::DisableSTDIOValueChangedCallback, this); 3137 3138 // Update m_launch_info once it was created 3139 Arg0ValueChangedCallback(this, NULL); 3140 RunArgsValueChangedCallback(this, NULL); 3141 //EnvVarsValueChangedCallback(this, NULL); // FIXME: cause segfault in Target::GetPlatform() 3142 InputPathValueChangedCallback(this, NULL); 3143 OutputPathValueChangedCallback(this, NULL); 3144 ErrorPathValueChangedCallback(this, NULL); 3145 DetachOnErrorValueChangedCallback(this, NULL); 3146 DisableASLRValueChangedCallback(this, NULL); 3147 DisableSTDIOValueChangedCallback(this, NULL); 3148 } 3149 else 3150 { 3151 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target"))); 3152 m_collection_sp->Initialize(g_properties); 3153 m_collection_sp->AppendProperty(ConstString("process"), 3154 ConstString("Settings specify to processes."), 3155 true, 3156 Process::GetGlobalProperties()->GetValueProperties()); 3157 } 3158 3159 } 3160 3161 TargetProperties::~TargetProperties () 3162 { 3163 } 3164 ArchSpec 3165 TargetProperties::GetDefaultArchitecture () const 3166 { 3167 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch); 3168 if (value) 3169 return value->GetCurrentValue(); 3170 return ArchSpec(); 3171 } 3172 3173 void 3174 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch) 3175 { 3176 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch); 3177 if (value) 3178 return value->SetCurrentValue(arch, true); 3179 } 3180 3181 lldb::DynamicValueType 3182 TargetProperties::GetPreferDynamicValue() const 3183 { 3184 const uint32_t idx = ePropertyPreferDynamic; 3185 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 3186 } 3187 3188 bool 3189 TargetProperties::GetDisableASLR () const 3190 { 3191 const uint32_t idx = ePropertyDisableASLR; 3192 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3193 } 3194 3195 void 3196 TargetProperties::SetDisableASLR (bool b) 3197 { 3198 const uint32_t idx = ePropertyDisableASLR; 3199 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 3200 } 3201 3202 bool 3203 TargetProperties::GetDetachOnError () const 3204 { 3205 const uint32_t idx = ePropertyDetachOnError; 3206 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3207 } 3208 3209 void 3210 TargetProperties::SetDetachOnError (bool b) 3211 { 3212 const uint32_t idx = ePropertyDetachOnError; 3213 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 3214 } 3215 3216 bool 3217 TargetProperties::GetDisableSTDIO () const 3218 { 3219 const uint32_t idx = ePropertyDisableSTDIO; 3220 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3221 } 3222 3223 void 3224 TargetProperties::SetDisableSTDIO (bool b) 3225 { 3226 const uint32_t idx = ePropertyDisableSTDIO; 3227 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 3228 } 3229 3230 const char * 3231 TargetProperties::GetDisassemblyFlavor () const 3232 { 3233 const uint32_t idx = ePropertyDisassemblyFlavor; 3234 const char *return_value; 3235 3236 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 3237 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value; 3238 return return_value; 3239 } 3240 3241 InlineStrategy 3242 TargetProperties::GetInlineStrategy () const 3243 { 3244 const uint32_t idx = ePropertyInlineStrategy; 3245 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 3246 } 3247 3248 const char * 3249 TargetProperties::GetArg0 () const 3250 { 3251 const uint32_t idx = ePropertyArg0; 3252 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, NULL); 3253 } 3254 3255 void 3256 TargetProperties::SetArg0 (const char *arg) 3257 { 3258 const uint32_t idx = ePropertyArg0; 3259 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, arg); 3260 m_launch_info.SetArg0(arg); 3261 } 3262 3263 bool 3264 TargetProperties::GetRunArguments (Args &args) const 3265 { 3266 const uint32_t idx = ePropertyRunArgs; 3267 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, args); 3268 } 3269 3270 void 3271 TargetProperties::SetRunArguments (const Args &args) 3272 { 3273 const uint32_t idx = ePropertyRunArgs; 3274 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, args); 3275 m_launch_info.GetArguments() = args; 3276 } 3277 3278 size_t 3279 TargetProperties::GetEnvironmentAsArgs (Args &env) const 3280 { 3281 const uint32_t idx = ePropertyEnvVars; 3282 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, env); 3283 } 3284 3285 void 3286 TargetProperties::SetEnvironmentFromArgs (const Args &env) 3287 { 3288 const uint32_t idx = ePropertyEnvVars; 3289 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, env); 3290 m_launch_info.GetEnvironmentEntries() = env; 3291 } 3292 3293 bool 3294 TargetProperties::GetSkipPrologue() const 3295 { 3296 const uint32_t idx = ePropertySkipPrologue; 3297 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3298 } 3299 3300 PathMappingList & 3301 TargetProperties::GetSourcePathMap () const 3302 { 3303 const uint32_t idx = ePropertySourceMap; 3304 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings (NULL, false, idx); 3305 assert(option_value); 3306 return option_value->GetCurrentValue(); 3307 } 3308 3309 FileSpecList & 3310 TargetProperties::GetExecutableSearchPaths () 3311 { 3312 const uint32_t idx = ePropertyExecutableSearchPaths; 3313 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx); 3314 assert(option_value); 3315 return option_value->GetCurrentValue(); 3316 } 3317 3318 FileSpecList & 3319 TargetProperties::GetDebugFileSearchPaths () 3320 { 3321 const uint32_t idx = ePropertyDebugFileSearchPaths; 3322 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx); 3323 assert(option_value); 3324 return option_value->GetCurrentValue(); 3325 } 3326 3327 FileSpecList & 3328 TargetProperties::GetClangModuleSearchPaths () 3329 { 3330 const uint32_t idx = ePropertyClangModuleSearchPaths; 3331 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx); 3332 assert(option_value); 3333 return option_value->GetCurrentValue(); 3334 } 3335 3336 bool 3337 TargetProperties::GetEnableAutoImportClangModules() const 3338 { 3339 const uint32_t idx = ePropertyAutoImportClangModules; 3340 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3341 } 3342 3343 bool 3344 TargetProperties::GetEnableSyntheticValue () const 3345 { 3346 const uint32_t idx = ePropertyEnableSynthetic; 3347 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3348 } 3349 3350 uint32_t 3351 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const 3352 { 3353 const uint32_t idx = ePropertyMaxChildrenCount; 3354 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 3355 } 3356 3357 uint32_t 3358 TargetProperties::GetMaximumSizeOfStringSummary() const 3359 { 3360 const uint32_t idx = ePropertyMaxSummaryLength; 3361 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 3362 } 3363 3364 uint32_t 3365 TargetProperties::GetMaximumMemReadSize () const 3366 { 3367 const uint32_t idx = ePropertyMaxMemReadSize; 3368 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 3369 } 3370 3371 FileSpec 3372 TargetProperties::GetStandardInputPath () const 3373 { 3374 const uint32_t idx = ePropertyInputPath; 3375 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 3376 } 3377 3378 void 3379 TargetProperties::SetStandardInputPath (const char *p) 3380 { 3381 const uint32_t idx = ePropertyInputPath; 3382 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 3383 } 3384 3385 FileSpec 3386 TargetProperties::GetStandardOutputPath () const 3387 { 3388 const uint32_t idx = ePropertyOutputPath; 3389 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 3390 } 3391 3392 void 3393 TargetProperties::SetStandardOutputPath (const char *p) 3394 { 3395 const uint32_t idx = ePropertyOutputPath; 3396 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 3397 } 3398 3399 FileSpec 3400 TargetProperties::GetStandardErrorPath () const 3401 { 3402 const uint32_t idx = ePropertyErrorPath; 3403 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx); 3404 } 3405 3406 const char * 3407 TargetProperties::GetExpressionPrefixContentsAsCString () 3408 { 3409 const uint32_t idx = ePropertyExprPrefix; 3410 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec (NULL, false, idx); 3411 if (file) 3412 { 3413 const bool null_terminate = true; 3414 DataBufferSP data_sp(file->GetFileContents(null_terminate)); 3415 if (data_sp) 3416 return (const char *) data_sp->GetBytes(); 3417 } 3418 return NULL; 3419 } 3420 3421 void 3422 TargetProperties::SetStandardErrorPath (const char *p) 3423 { 3424 const uint32_t idx = ePropertyErrorPath; 3425 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 3426 } 3427 3428 bool 3429 TargetProperties::GetBreakpointsConsultPlatformAvoidList () 3430 { 3431 const uint32_t idx = ePropertyBreakpointUseAvoidList; 3432 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3433 } 3434 3435 bool 3436 TargetProperties::GetUseHexImmediates () const 3437 { 3438 const uint32_t idx = ePropertyUseHexImmediates; 3439 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3440 } 3441 3442 bool 3443 TargetProperties::GetUseFastStepping () const 3444 { 3445 const uint32_t idx = ePropertyUseFastStepping; 3446 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3447 } 3448 3449 bool 3450 TargetProperties::GetDisplayExpressionsInCrashlogs () const 3451 { 3452 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs; 3453 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 3454 } 3455 3456 LoadScriptFromSymFile 3457 TargetProperties::GetLoadScriptFromSymbolFile () const 3458 { 3459 const uint32_t idx = ePropertyLoadScriptFromSymbolFile; 3460 return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value); 3461 } 3462 3463 Disassembler::HexImmediateStyle 3464 TargetProperties::GetHexImmediateStyle () const 3465 { 3466 const uint32_t idx = ePropertyHexImmediateStyle; 3467 return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value); 3468 } 3469 3470 MemoryModuleLoadLevel 3471 TargetProperties::GetMemoryModuleLoadLevel() const 3472 { 3473 const uint32_t idx = ePropertyMemoryModuleLoadLevel; 3474 return (MemoryModuleLoadLevel)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value); 3475 } 3476 3477 bool 3478 TargetProperties::GetUserSpecifiedTrapHandlerNames (Args &args) const 3479 { 3480 const uint32_t idx = ePropertyTrapHandlerNames; 3481 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, args); 3482 } 3483 3484 void 3485 TargetProperties::SetUserSpecifiedTrapHandlerNames (const Args &args) 3486 { 3487 const uint32_t idx = ePropertyTrapHandlerNames; 3488 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, args); 3489 } 3490 3491 bool 3492 TargetProperties::GetDisplayRuntimeSupportValues () const 3493 { 3494 const uint32_t idx = ePropertyDisplayRuntimeSupportValues; 3495 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, false); 3496 } 3497 3498 void 3499 TargetProperties::SetDisplayRuntimeSupportValues (bool b) 3500 { 3501 const uint32_t idx = ePropertyDisplayRuntimeSupportValues; 3502 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 3503 } 3504 3505 const ProcessLaunchInfo & 3506 TargetProperties::GetProcessLaunchInfo () 3507 { 3508 m_launch_info.SetArg0(GetArg0()); // FIXME: Arg0 callback doesn't work 3509 return m_launch_info; 3510 } 3511 3512 void 3513 TargetProperties::SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info) 3514 { 3515 m_launch_info = launch_info; 3516 SetArg0(launch_info.GetArg0()); 3517 SetRunArguments(launch_info.GetArguments()); 3518 SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries()); 3519 const FileAction *input_file_action = launch_info.GetFileActionForFD(STDIN_FILENO); 3520 if (input_file_action) 3521 { 3522 const char *input_path = input_file_action->GetPath(); 3523 if (input_path) 3524 SetStandardInputPath(input_path); 3525 } 3526 const FileAction *output_file_action = launch_info.GetFileActionForFD(STDOUT_FILENO); 3527 if (output_file_action) 3528 { 3529 const char *output_path = output_file_action->GetPath(); 3530 if (output_path) 3531 SetStandardOutputPath(output_path); 3532 } 3533 const FileAction *error_file_action = launch_info.GetFileActionForFD(STDERR_FILENO); 3534 if (error_file_action) 3535 { 3536 const char *error_path = error_file_action->GetPath(); 3537 if (error_path) 3538 SetStandardErrorPath(error_path); 3539 } 3540 SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError)); 3541 SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR)); 3542 SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO)); 3543 } 3544 3545 void 3546 TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *) 3547 { 3548 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3549 this_->m_launch_info.SetArg0(this_->GetArg0()); 3550 } 3551 3552 void 3553 TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *) 3554 { 3555 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3556 Args args; 3557 if (this_->GetRunArguments(args)) 3558 this_->m_launch_info.GetArguments() = args; 3559 } 3560 3561 void 3562 TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *) 3563 { 3564 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3565 Args args; 3566 if (this_->GetEnvironmentAsArgs(args)) 3567 this_->m_launch_info.GetEnvironmentEntries() = args; 3568 } 3569 3570 void 3571 TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *) 3572 { 3573 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3574 this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath().GetPath().c_str(), true, false); 3575 } 3576 3577 void 3578 TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *) 3579 { 3580 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3581 this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath().GetPath().c_str(), false, true); 3582 } 3583 3584 void 3585 TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *) 3586 { 3587 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3588 this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath().GetPath().c_str(), false, true); 3589 } 3590 3591 void 3592 TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *) 3593 { 3594 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3595 if (this_->GetDetachOnError()) 3596 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError); 3597 else 3598 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError); 3599 } 3600 3601 void 3602 TargetProperties::DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *) 3603 { 3604 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3605 if (this_->GetDisableASLR()) 3606 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR); 3607 else 3608 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR); 3609 } 3610 3611 void 3612 TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *) 3613 { 3614 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr); 3615 if (this_->GetDisableSTDIO()) 3616 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO); 3617 else 3618 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO); 3619 } 3620 3621 //---------------------------------------------------------------------- 3622 // Target::TargetEventData 3623 //---------------------------------------------------------------------- 3624 3625 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp) : 3626 EventData (), 3627 m_target_sp (target_sp), 3628 m_module_list () 3629 { 3630 } 3631 3632 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list) : 3633 EventData (), 3634 m_target_sp (target_sp), 3635 m_module_list (module_list) 3636 { 3637 } 3638 3639 Target::TargetEventData::~TargetEventData() 3640 { 3641 } 3642 3643 const ConstString & 3644 Target::TargetEventData::GetFlavorString () 3645 { 3646 static ConstString g_flavor ("Target::TargetEventData"); 3647 return g_flavor; 3648 } 3649 3650 void 3651 Target::TargetEventData::Dump (Stream *s) const 3652 { 3653 } 3654 3655 const Target::TargetEventData * 3656 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr) 3657 { 3658 if (event_ptr) 3659 { 3660 const EventData *event_data = event_ptr->GetData(); 3661 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString()) 3662 return static_cast <const TargetEventData *> (event_ptr->GetData()); 3663 } 3664 return NULL; 3665 } 3666 3667 TargetSP 3668 Target::TargetEventData::GetTargetFromEvent (const Event *event_ptr) 3669 { 3670 TargetSP target_sp; 3671 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr); 3672 if (event_data) 3673 target_sp = event_data->m_target_sp; 3674 return target_sp; 3675 } 3676 3677 ModuleList 3678 Target::TargetEventData::GetModuleListFromEvent (const Event *event_ptr) 3679 { 3680 ModuleList module_list; 3681 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr); 3682 if (event_data) 3683 module_list = event_data->m_module_list; 3684 return module_list; 3685 } 3686