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/StreamString.h" 32 #include "lldb/Core/Timer.h" 33 #include "lldb/Core/ValueObject.h" 34 #include "lldb/Expression/ClangASTSource.h" 35 #include "lldb/Expression/ClangUserExpression.h" 36 #include "lldb/Host/Host.h" 37 #include "lldb/Interpreter/CommandInterpreter.h" 38 #include "lldb/Interpreter/CommandReturnObject.h" 39 #include "lldb/Interpreter/OptionGroupWatchpoint.h" 40 #include "lldb/Interpreter/OptionValues.h" 41 #include "lldb/Interpreter/Property.h" 42 #include "lldb/lldb-private-log.h" 43 #include "lldb/Symbol/ObjectFile.h" 44 #include "lldb/Target/Process.h" 45 #include "lldb/Target/StackFrame.h" 46 #include "lldb/Target/Thread.h" 47 #include "lldb/Target/ThreadSpec.h" 48 49 using namespace lldb; 50 using namespace lldb_private; 51 52 ConstString & 53 Target::GetStaticBroadcasterClass () 54 { 55 static ConstString class_name ("lldb.target"); 56 return class_name; 57 } 58 59 //---------------------------------------------------------------------- 60 // Target constructor 61 //---------------------------------------------------------------------- 62 Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp) : 63 TargetProperties (this), 64 Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()), 65 ExecutionContextScope (), 66 m_debugger (debugger), 67 m_platform_sp (platform_sp), 68 m_mutex (Mutex::eMutexTypeRecursive), 69 m_arch (target_arch), 70 m_images (this), 71 m_section_load_list (), 72 m_breakpoint_list (false), 73 m_internal_breakpoint_list (true), 74 m_watchpoint_list (), 75 m_process_sp (), 76 m_valid (true), 77 m_search_filter_sp (), 78 m_image_search_paths (ImageSearchPathsChanged, this), 79 m_scratch_ast_context_ap (NULL), 80 m_scratch_ast_source_ap (NULL), 81 m_ast_importer_ap (NULL), 82 m_persistent_variables (), 83 m_source_manager_ap(), 84 m_stop_hooks (), 85 m_stop_hook_next_id (0), 86 m_suppress_stop_hooks (false), 87 m_suppress_synthetic_value(false) 88 { 89 SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed"); 90 SetEventName (eBroadcastBitModulesLoaded, "modules-loaded"); 91 SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded"); 92 SetEventName (eBroadcastBitWatchpointChanged, "watchpoint-changed"); 93 94 CheckInWithManager(); 95 96 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 97 if (log) 98 log->Printf ("%p Target::Target()", this); 99 if (m_arch.IsValid()) 100 { 101 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 102 } 103 } 104 105 //---------------------------------------------------------------------- 106 // Destructor 107 //---------------------------------------------------------------------- 108 Target::~Target() 109 { 110 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 111 if (log) 112 log->Printf ("%p Target::~Target()", this); 113 DeleteCurrentProcess (); 114 } 115 116 void 117 Target::Dump (Stream *s, lldb::DescriptionLevel description_level) 118 { 119 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 120 if (description_level != lldb::eDescriptionLevelBrief) 121 { 122 s->Indent(); 123 s->PutCString("Target\n"); 124 s->IndentMore(); 125 m_images.Dump(s); 126 m_breakpoint_list.Dump(s); 127 m_internal_breakpoint_list.Dump(s); 128 s->IndentLess(); 129 } 130 else 131 { 132 Module *exe_module = GetExecutableModulePointer(); 133 if (exe_module) 134 s->PutCString (exe_module->GetFileSpec().GetFilename().GetCString()); 135 else 136 s->PutCString ("No executable module."); 137 } 138 } 139 140 void 141 Target::CleanupProcess () 142 { 143 // Do any cleanup of the target we need to do between process instances. 144 // NB It is better to do this before destroying the process in case the 145 // clean up needs some help from the process. 146 m_breakpoint_list.ClearAllBreakpointSites(); 147 m_internal_breakpoint_list.ClearAllBreakpointSites(); 148 // Disable watchpoints just on the debugger side. 149 Mutex::Locker locker; 150 this->GetWatchpointList().GetListMutex(locker); 151 DisableAllWatchpoints(false); 152 ClearAllWatchpointHitCounts(); 153 } 154 155 void 156 Target::DeleteCurrentProcess () 157 { 158 if (m_process_sp.get()) 159 { 160 m_section_load_list.Clear(); 161 if (m_process_sp->IsAlive()) 162 m_process_sp->Destroy(); 163 164 m_process_sp->Finalize(); 165 166 CleanupProcess (); 167 168 m_process_sp.reset(); 169 } 170 } 171 172 const lldb::ProcessSP & 173 Target::CreateProcess (Listener &listener, const char *plugin_name, const FileSpec *crash_file) 174 { 175 DeleteCurrentProcess (); 176 m_process_sp = Process::FindPlugin(*this, plugin_name, listener, crash_file); 177 return m_process_sp; 178 } 179 180 const lldb::ProcessSP & 181 Target::GetProcessSP () const 182 { 183 return m_process_sp; 184 } 185 186 void 187 Target::Destroy() 188 { 189 Mutex::Locker locker (m_mutex); 190 m_valid = false; 191 DeleteCurrentProcess (); 192 m_platform_sp.reset(); 193 m_arch.Clear(); 194 m_images.Clear(); 195 m_section_load_list.Clear(); 196 const bool notify = false; 197 m_breakpoint_list.RemoveAll(notify); 198 m_internal_breakpoint_list.RemoveAll(notify); 199 m_last_created_breakpoint.reset(); 200 m_last_created_watchpoint.reset(); 201 m_search_filter_sp.reset(); 202 m_image_search_paths.Clear(notify); 203 m_scratch_ast_context_ap.reset(); 204 m_scratch_ast_source_ap.reset(); 205 m_ast_importer_ap.reset(); 206 m_persistent_variables.Clear(); 207 m_stop_hooks.clear(); 208 m_stop_hook_next_id = 0; 209 m_suppress_stop_hooks = false; 210 m_suppress_synthetic_value = false; 211 } 212 213 214 BreakpointList & 215 Target::GetBreakpointList(bool internal) 216 { 217 if (internal) 218 return m_internal_breakpoint_list; 219 else 220 return m_breakpoint_list; 221 } 222 223 const BreakpointList & 224 Target::GetBreakpointList(bool internal) const 225 { 226 if (internal) 227 return m_internal_breakpoint_list; 228 else 229 return m_breakpoint_list; 230 } 231 232 BreakpointSP 233 Target::GetBreakpointByID (break_id_t break_id) 234 { 235 BreakpointSP bp_sp; 236 237 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 238 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 239 else 240 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 241 242 return bp_sp; 243 } 244 245 BreakpointSP 246 Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules, 247 const FileSpecList *source_file_spec_list, 248 RegularExpression &source_regex, 249 bool internal) 250 { 251 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list)); 252 BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex (NULL, source_regex)); 253 return CreateBreakpoint (filter_sp, resolver_sp, internal); 254 } 255 256 257 BreakpointSP 258 Target::CreateBreakpoint (const FileSpecList *containingModules, 259 const FileSpec &file, 260 uint32_t line_no, 261 LazyBool check_inlines, 262 LazyBool skip_prologue, 263 bool internal) 264 { 265 if (check_inlines == eLazyBoolCalculate) 266 { 267 const InlineStrategy inline_strategy = GetInlineStrategy(); 268 switch (inline_strategy) 269 { 270 case eInlineBreakpointsNever: 271 check_inlines = eLazyBoolNo; 272 break; 273 274 case eInlineBreakpointsHeaders: 275 if (file.IsSourceImplementationFile()) 276 check_inlines = eLazyBoolNo; 277 else 278 check_inlines = eLazyBoolYes; 279 break; 280 281 case eInlineBreakpointsAlways: 282 check_inlines = eLazyBoolYes; 283 break; 284 } 285 } 286 SearchFilterSP filter_sp; 287 if (check_inlines == eLazyBoolNo) 288 { 289 // Not checking for inlines, we are looking only for matching compile units 290 FileSpecList compile_unit_list; 291 compile_unit_list.Append (file); 292 filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list); 293 } 294 else 295 { 296 filter_sp = GetSearchFilterForModuleList (containingModules); 297 } 298 BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (NULL, 299 file, 300 line_no, 301 check_inlines, 302 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); 303 return CreateBreakpoint (filter_sp, resolver_sp, internal); 304 } 305 306 307 BreakpointSP 308 Target::CreateBreakpoint (lldb::addr_t addr, bool internal) 309 { 310 Address so_addr; 311 // Attempt to resolve our load address if possible, though it is ok if 312 // it doesn't resolve to section/offset. 313 314 // Try and resolve as a load address if possible 315 m_section_load_list.ResolveLoadAddress(addr, so_addr); 316 if (!so_addr.IsValid()) 317 { 318 // The address didn't resolve, so just set this as an absolute address 319 so_addr.SetOffset (addr); 320 } 321 BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal)); 322 return bp_sp; 323 } 324 325 BreakpointSP 326 Target::CreateBreakpoint (Address &addr, bool internal) 327 { 328 SearchFilterSP filter_sp(new SearchFilterForNonModuleSpecificSearches (shared_from_this())); 329 BreakpointResolverSP resolver_sp (new BreakpointResolverAddress (NULL, addr)); 330 return CreateBreakpoint (filter_sp, resolver_sp, internal); 331 } 332 333 BreakpointSP 334 Target::CreateBreakpoint (const FileSpecList *containingModules, 335 const FileSpecList *containingSourceFiles, 336 const char *func_name, 337 uint32_t func_name_type_mask, 338 LazyBool skip_prologue, 339 bool internal) 340 { 341 BreakpointSP bp_sp; 342 if (func_name) 343 { 344 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 345 346 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 347 func_name, 348 func_name_type_mask, 349 Breakpoint::Exact, 350 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); 351 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal); 352 } 353 return bp_sp; 354 } 355 356 lldb::BreakpointSP 357 Target::CreateBreakpoint (const FileSpecList *containingModules, 358 const FileSpecList *containingSourceFiles, 359 const std::vector<std::string> &func_names, 360 uint32_t func_name_type_mask, 361 LazyBool skip_prologue, 362 bool internal) 363 { 364 BreakpointSP bp_sp; 365 size_t num_names = func_names.size(); 366 if (num_names > 0) 367 { 368 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 369 370 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 371 func_names, 372 func_name_type_mask, 373 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); 374 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal); 375 } 376 return bp_sp; 377 } 378 379 BreakpointSP 380 Target::CreateBreakpoint (const FileSpecList *containingModules, 381 const FileSpecList *containingSourceFiles, 382 const char *func_names[], 383 size_t num_names, 384 uint32_t func_name_type_mask, 385 LazyBool skip_prologue, 386 bool internal) 387 { 388 BreakpointSP bp_sp; 389 if (num_names > 0) 390 { 391 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 392 393 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 394 func_names, 395 num_names, 396 func_name_type_mask, 397 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); 398 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal); 399 } 400 return bp_sp; 401 } 402 403 SearchFilterSP 404 Target::GetSearchFilterForModule (const FileSpec *containingModule) 405 { 406 SearchFilterSP filter_sp; 407 if (containingModule != NULL) 408 { 409 // TODO: We should look into sharing module based search filters 410 // across many breakpoints like we do for the simple target based one 411 filter_sp.reset (new SearchFilterByModule (shared_from_this(), *containingModule)); 412 } 413 else 414 { 415 if (m_search_filter_sp.get() == NULL) 416 m_search_filter_sp.reset (new SearchFilterForNonModuleSpecificSearches (shared_from_this())); 417 filter_sp = m_search_filter_sp; 418 } 419 return filter_sp; 420 } 421 422 SearchFilterSP 423 Target::GetSearchFilterForModuleList (const FileSpecList *containingModules) 424 { 425 SearchFilterSP filter_sp; 426 if (containingModules && containingModules->GetSize() != 0) 427 { 428 // TODO: We should look into sharing module based search filters 429 // across many breakpoints like we do for the simple target based one 430 filter_sp.reset (new SearchFilterByModuleList (shared_from_this(), *containingModules)); 431 } 432 else 433 { 434 if (m_search_filter_sp.get() == NULL) 435 m_search_filter_sp.reset (new SearchFilterForNonModuleSpecificSearches (shared_from_this())); 436 filter_sp = m_search_filter_sp; 437 } 438 return filter_sp; 439 } 440 441 SearchFilterSP 442 Target::GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules, 443 const FileSpecList *containingSourceFiles) 444 { 445 if (containingSourceFiles == NULL || containingSourceFiles->GetSize() == 0) 446 return GetSearchFilterForModuleList(containingModules); 447 448 SearchFilterSP filter_sp; 449 if (containingModules == NULL) 450 { 451 // We could make a special "CU List only SearchFilter". Better yet was if these could be composable, 452 // but that will take a little reworking. 453 454 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), FileSpecList(), *containingSourceFiles)); 455 } 456 else 457 { 458 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), *containingModules, *containingSourceFiles)); 459 } 460 return filter_sp; 461 } 462 463 BreakpointSP 464 Target::CreateFuncRegexBreakpoint (const FileSpecList *containingModules, 465 const FileSpecList *containingSourceFiles, 466 RegularExpression &func_regex, 467 LazyBool skip_prologue, 468 bool internal) 469 { 470 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles)); 471 BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL, 472 func_regex, 473 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); 474 475 return CreateBreakpoint (filter_sp, resolver_sp, internal); 476 } 477 478 lldb::BreakpointSP 479 Target::CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal) 480 { 481 return LanguageRuntime::CreateExceptionBreakpoint (*this, language, catch_bp, throw_bp, internal); 482 } 483 484 BreakpointSP 485 Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal) 486 { 487 BreakpointSP bp_sp; 488 if (filter_sp && resolver_sp) 489 { 490 bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp)); 491 resolver_sp->SetBreakpoint (bp_sp.get()); 492 493 if (internal) 494 m_internal_breakpoint_list.Add (bp_sp, false); 495 else 496 m_breakpoint_list.Add (bp_sp, true); 497 498 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 499 if (log) 500 { 501 StreamString s; 502 bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 503 log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, internal ? "yes" : "no", s.GetData()); 504 } 505 506 bp_sp->ResolveBreakpoint(); 507 } 508 509 if (!internal && bp_sp) 510 { 511 m_last_created_breakpoint = bp_sp; 512 } 513 514 return bp_sp; 515 } 516 517 bool 518 Target::ProcessIsValid() 519 { 520 return (m_process_sp && m_process_sp->IsAlive()); 521 } 522 523 static bool 524 CheckIfWatchpointsExhausted(Target *target, Error &error) 525 { 526 uint32_t num_supported_hardware_watchpoints; 527 Error rc = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints); 528 if (rc.Success()) 529 { 530 uint32_t num_current_watchpoints = target->GetWatchpointList().GetSize(); 531 if (num_current_watchpoints >= num_supported_hardware_watchpoints) 532 error.SetErrorStringWithFormat("number of supported hardware watchpoints (%u) has been reached", 533 num_supported_hardware_watchpoints); 534 } 535 return false; 536 } 537 538 // See also Watchpoint::SetWatchpointType(uint32_t type) and 539 // the OptionGroupWatchpoint::WatchType enum type. 540 WatchpointSP 541 Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const ClangASTType *type, uint32_t kind, Error &error) 542 { 543 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 544 if (log) 545 log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64 " type = %u)\n", 546 __FUNCTION__, addr, (uint64_t)size, kind); 547 548 WatchpointSP wp_sp; 549 if (!ProcessIsValid()) 550 { 551 error.SetErrorString("process is not alive"); 552 return wp_sp; 553 } 554 if (addr == LLDB_INVALID_ADDRESS || size == 0) 555 { 556 if (size == 0) 557 error.SetErrorString("cannot set a watchpoint with watch_size of 0"); 558 else 559 error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr); 560 return wp_sp; 561 } 562 563 // Currently we only support one watchpoint per address, with total number 564 // of watchpoints limited by the hardware which the inferior is running on. 565 566 // Grab the list mutex while doing operations. 567 const bool notify = false; // Don't notify about all the state changes we do on creating the watchpoint. 568 Mutex::Locker locker; 569 this->GetWatchpointList().GetListMutex(locker); 570 WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr); 571 if (matched_sp) 572 { 573 size_t old_size = matched_sp->GetByteSize(); 574 uint32_t old_type = 575 (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) | 576 (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0); 577 // Return the existing watchpoint if both size and type match. 578 if (size == old_size && kind == old_type) { 579 wp_sp = matched_sp; 580 wp_sp->SetEnabled(false, notify); 581 } else { 582 // Nil the matched watchpoint; we will be creating a new one. 583 m_process_sp->DisableWatchpoint(matched_sp.get(), notify); 584 m_watchpoint_list.Remove(matched_sp->GetID(), true); 585 } 586 } 587 588 if (!wp_sp) 589 { 590 wp_sp.reset(new Watchpoint(*this, addr, size, type)); 591 wp_sp->SetWatchpointType(kind, notify); 592 m_watchpoint_list.Add (wp_sp, true); 593 } 594 595 error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify); 596 if (log) 597 log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n", 598 __FUNCTION__, 599 error.Success() ? "succeeded" : "failed", 600 wp_sp->GetID()); 601 602 if (error.Fail()) 603 { 604 // Enabling the watchpoint on the device side failed. 605 // Remove the said watchpoint from the list maintained by the target instance. 606 m_watchpoint_list.Remove (wp_sp->GetID(), true); 607 // See if we could provide more helpful error message. 608 if (!CheckIfWatchpointsExhausted(this, error)) 609 { 610 if (!OptionGroupWatchpoint::IsWatchSizeSupported(size)) 611 error.SetErrorStringWithFormat("watch size of %lu is not supported", size); 612 } 613 wp_sp.reset(); 614 } 615 else 616 m_last_created_watchpoint = wp_sp; 617 return wp_sp; 618 } 619 620 void 621 Target::RemoveAllBreakpoints (bool internal_also) 622 { 623 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 624 if (log) 625 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 626 627 m_breakpoint_list.RemoveAll (true); 628 if (internal_also) 629 m_internal_breakpoint_list.RemoveAll (false); 630 631 m_last_created_breakpoint.reset(); 632 } 633 634 void 635 Target::DisableAllBreakpoints (bool internal_also) 636 { 637 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 638 if (log) 639 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 640 641 m_breakpoint_list.SetEnabledAll (false); 642 if (internal_also) 643 m_internal_breakpoint_list.SetEnabledAll (false); 644 } 645 646 void 647 Target::EnableAllBreakpoints (bool internal_also) 648 { 649 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 650 if (log) 651 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 652 653 m_breakpoint_list.SetEnabledAll (true); 654 if (internal_also) 655 m_internal_breakpoint_list.SetEnabledAll (true); 656 } 657 658 bool 659 Target::RemoveBreakpointByID (break_id_t break_id) 660 { 661 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 662 if (log) 663 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 664 665 if (DisableBreakpointByID (break_id)) 666 { 667 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 668 m_internal_breakpoint_list.Remove(break_id, false); 669 else 670 { 671 if (m_last_created_breakpoint) 672 { 673 if (m_last_created_breakpoint->GetID() == break_id) 674 m_last_created_breakpoint.reset(); 675 } 676 m_breakpoint_list.Remove(break_id, true); 677 } 678 return true; 679 } 680 return false; 681 } 682 683 bool 684 Target::DisableBreakpointByID (break_id_t break_id) 685 { 686 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 687 if (log) 688 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 689 690 BreakpointSP bp_sp; 691 692 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 693 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 694 else 695 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 696 if (bp_sp) 697 { 698 bp_sp->SetEnabled (false); 699 return true; 700 } 701 return false; 702 } 703 704 bool 705 Target::EnableBreakpointByID (break_id_t break_id) 706 { 707 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 708 if (log) 709 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", 710 __FUNCTION__, 711 break_id, 712 LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 713 714 BreakpointSP bp_sp; 715 716 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 717 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 718 else 719 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 720 721 if (bp_sp) 722 { 723 bp_sp->SetEnabled (true); 724 return true; 725 } 726 return false; 727 } 728 729 // The flag 'end_to_end', default to true, signifies that the operation is 730 // performed end to end, for both the debugger and the debuggee. 731 732 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end 733 // to end operations. 734 bool 735 Target::RemoveAllWatchpoints (bool end_to_end) 736 { 737 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 738 if (log) 739 log->Printf ("Target::%s\n", __FUNCTION__); 740 741 if (!end_to_end) { 742 m_watchpoint_list.RemoveAll(true); 743 return true; 744 } 745 746 // Otherwise, it's an end to end operation. 747 748 if (!ProcessIsValid()) 749 return false; 750 751 size_t num_watchpoints = m_watchpoint_list.GetSize(); 752 for (size_t i = 0; i < num_watchpoints; ++i) 753 { 754 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 755 if (!wp_sp) 756 return false; 757 758 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 759 if (rc.Fail()) 760 return false; 761 } 762 m_watchpoint_list.RemoveAll (true); 763 return true; // Success! 764 } 765 766 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to 767 // end operations. 768 bool 769 Target::DisableAllWatchpoints (bool end_to_end) 770 { 771 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 772 if (log) 773 log->Printf ("Target::%s\n", __FUNCTION__); 774 775 if (!end_to_end) { 776 m_watchpoint_list.SetEnabledAll(false); 777 return true; 778 } 779 780 // Otherwise, it's an end to end operation. 781 782 if (!ProcessIsValid()) 783 return false; 784 785 size_t num_watchpoints = m_watchpoint_list.GetSize(); 786 for (size_t i = 0; i < num_watchpoints; ++i) 787 { 788 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 789 if (!wp_sp) 790 return false; 791 792 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 793 if (rc.Fail()) 794 return false; 795 } 796 return true; // Success! 797 } 798 799 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to 800 // end operations. 801 bool 802 Target::EnableAllWatchpoints (bool end_to_end) 803 { 804 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 805 if (log) 806 log->Printf ("Target::%s\n", __FUNCTION__); 807 808 if (!end_to_end) { 809 m_watchpoint_list.SetEnabledAll(true); 810 return true; 811 } 812 813 // Otherwise, it's an end to end operation. 814 815 if (!ProcessIsValid()) 816 return false; 817 818 size_t num_watchpoints = m_watchpoint_list.GetSize(); 819 for (size_t i = 0; i < num_watchpoints; ++i) 820 { 821 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 822 if (!wp_sp) 823 return false; 824 825 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get()); 826 if (rc.Fail()) 827 return false; 828 } 829 return true; // Success! 830 } 831 832 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 833 bool 834 Target::ClearAllWatchpointHitCounts () 835 { 836 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 837 if (log) 838 log->Printf ("Target::%s\n", __FUNCTION__); 839 840 size_t num_watchpoints = m_watchpoint_list.GetSize(); 841 for (size_t i = 0; i < num_watchpoints; ++i) 842 { 843 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 844 if (!wp_sp) 845 return false; 846 847 wp_sp->ResetHitCount(); 848 } 849 return true; // Success! 850 } 851 852 // Assumption: Caller holds the list mutex lock for m_watchpoint_list 853 // during these operations. 854 bool 855 Target::IgnoreAllWatchpoints (uint32_t ignore_count) 856 { 857 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 858 if (log) 859 log->Printf ("Target::%s\n", __FUNCTION__); 860 861 if (!ProcessIsValid()) 862 return false; 863 864 size_t num_watchpoints = m_watchpoint_list.GetSize(); 865 for (size_t i = 0; i < num_watchpoints; ++i) 866 { 867 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i); 868 if (!wp_sp) 869 return false; 870 871 wp_sp->SetIgnoreCount(ignore_count); 872 } 873 return true; // Success! 874 } 875 876 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 877 bool 878 Target::DisableWatchpointByID (lldb::watch_id_t watch_id) 879 { 880 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 881 if (log) 882 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 883 884 if (!ProcessIsValid()) 885 return false; 886 887 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 888 if (wp_sp) 889 { 890 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get()); 891 if (rc.Success()) 892 return true; 893 894 // Else, fallthrough. 895 } 896 return false; 897 } 898 899 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 900 bool 901 Target::EnableWatchpointByID (lldb::watch_id_t watch_id) 902 { 903 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 904 if (log) 905 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 906 907 if (!ProcessIsValid()) 908 return false; 909 910 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 911 if (wp_sp) 912 { 913 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get()); 914 if (rc.Success()) 915 return true; 916 917 // Else, fallthrough. 918 } 919 return false; 920 } 921 922 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 923 bool 924 Target::RemoveWatchpointByID (lldb::watch_id_t watch_id) 925 { 926 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 927 if (log) 928 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 929 930 if (DisableWatchpointByID (watch_id)) 931 { 932 m_watchpoint_list.Remove(watch_id, true); 933 return true; 934 } 935 return false; 936 } 937 938 // Assumption: Caller holds the list mutex lock for m_watchpoint_list. 939 bool 940 Target::IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count) 941 { 942 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS)); 943 if (log) 944 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id); 945 946 if (!ProcessIsValid()) 947 return false; 948 949 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id); 950 if (wp_sp) 951 { 952 wp_sp->SetIgnoreCount(ignore_count); 953 return true; 954 } 955 return false; 956 } 957 958 ModuleSP 959 Target::GetExecutableModule () 960 { 961 return m_images.GetModuleAtIndex(0); 962 } 963 964 Module* 965 Target::GetExecutableModulePointer () 966 { 967 return m_images.GetModulePointerAtIndex(0); 968 } 969 970 static void 971 LoadScriptingResourceForModule (const ModuleSP &module_sp, Target *target) 972 { 973 Error error; 974 if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error)) 975 { 976 target->GetDebugger().GetOutputStream().Printf("unable to load scripting data for module %s - error reported was %s\n", 977 module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(), 978 error.AsCString()); 979 } 980 } 981 982 void 983 Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files) 984 { 985 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 986 m_images.Clear(); 987 m_scratch_ast_context_ap.reset(); 988 m_scratch_ast_source_ap.reset(); 989 m_ast_importer_ap.reset(); 990 991 if (executable_sp.get()) 992 { 993 Timer scoped_timer (__PRETTY_FUNCTION__, 994 "Target::SetExecutableModule (executable = '%s/%s')", 995 executable_sp->GetFileSpec().GetDirectory().AsCString(), 996 executable_sp->GetFileSpec().GetFilename().AsCString()); 997 998 m_images.Append(executable_sp); // The first image is our exectuable file 999 1000 // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module. 1001 if (!m_arch.IsValid()) 1002 { 1003 m_arch = executable_sp->GetArchitecture(); 1004 if (log) 1005 log->Printf ("Target::SetExecutableModule setting architecture to %s (%s) based on executable file", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str()); 1006 } 1007 1008 FileSpecList dependent_files; 1009 ObjectFile *executable_objfile = executable_sp->GetObjectFile(); 1010 1011 if (executable_objfile && get_dependent_files) 1012 { 1013 executable_objfile->GetDependentModules(dependent_files); 1014 for (uint32_t i=0; i<dependent_files.GetSize(); i++) 1015 { 1016 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i)); 1017 FileSpec platform_dependent_file_spec; 1018 if (m_platform_sp) 1019 m_platform_sp->GetFile (dependent_file_spec, NULL, platform_dependent_file_spec); 1020 else 1021 platform_dependent_file_spec = dependent_file_spec; 1022 1023 ModuleSpec module_spec (platform_dependent_file_spec, m_arch); 1024 ModuleSP image_module_sp(GetSharedModule (module_spec)); 1025 if (image_module_sp.get()) 1026 { 1027 ObjectFile *objfile = image_module_sp->GetObjectFile(); 1028 if (objfile) 1029 objfile->GetDependentModules(dependent_files); 1030 } 1031 } 1032 } 1033 } 1034 } 1035 1036 1037 bool 1038 Target::SetArchitecture (const ArchSpec &arch_spec) 1039 { 1040 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET)); 1041 if (m_arch.IsCompatibleMatch(arch_spec) || !m_arch.IsValid()) 1042 { 1043 // If we haven't got a valid arch spec, or the architectures are 1044 // compatible, so just update the architecture. Architectures can be 1045 // equal, yet the triple OS and vendor might change, so we need to do 1046 // the assignment here just in case. 1047 m_arch = arch_spec; 1048 if (log) 1049 log->Printf ("Target::SetArchitecture setting architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1050 return true; 1051 } 1052 else 1053 { 1054 // If we have an executable file, try to reset the executable to the desired architecture 1055 if (log) 1056 log->Printf ("Target::SetArchitecture changing architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1057 m_arch = arch_spec; 1058 ModuleSP executable_sp = GetExecutableModule (); 1059 m_images.Clear(); 1060 m_scratch_ast_context_ap.reset(); 1061 m_scratch_ast_source_ap.reset(); 1062 m_ast_importer_ap.reset(); 1063 // Need to do something about unsetting breakpoints. 1064 1065 if (executable_sp) 1066 { 1067 if (log) 1068 log->Printf("Target::SetArchitecture Trying to select executable file architecture %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str()); 1069 ModuleSpec module_spec (executable_sp->GetFileSpec(), arch_spec); 1070 Error error = ModuleList::GetSharedModule (module_spec, 1071 executable_sp, 1072 &GetExecutableSearchPaths(), 1073 NULL, 1074 NULL); 1075 1076 if (!error.Fail() && executable_sp) 1077 { 1078 SetExecutableModule (executable_sp, true); 1079 return true; 1080 } 1081 } 1082 } 1083 return false; 1084 } 1085 1086 void 1087 Target::WillClearList (const ModuleList& module_list) 1088 { 1089 } 1090 1091 void 1092 Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp) 1093 { 1094 // A module is being added to this target for the first time 1095 ModuleList my_module_list; 1096 my_module_list.Append(module_sp); 1097 LoadScriptingResourceForModule(module_sp, this); 1098 ModulesDidLoad (my_module_list); 1099 } 1100 1101 void 1102 Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp) 1103 { 1104 // A module is being added to this target for the first time 1105 ModuleList my_module_list; 1106 my_module_list.Append(module_sp); 1107 ModulesDidUnload (my_module_list); 1108 } 1109 1110 void 1111 Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp) 1112 { 1113 // A module is replacing an already added module 1114 m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp); 1115 } 1116 1117 void 1118 Target::ModulesDidLoad (ModuleList &module_list) 1119 { 1120 if (module_list.GetSize()) 1121 { 1122 m_breakpoint_list.UpdateBreakpoints (module_list, true); 1123 // TODO: make event data that packages up the module_list 1124 BroadcastEvent (eBroadcastBitModulesLoaded, NULL); 1125 } 1126 } 1127 1128 void 1129 Target::ModulesDidUnload (ModuleList &module_list) 1130 { 1131 if (module_list.GetSize()) 1132 { 1133 m_breakpoint_list.UpdateBreakpoints (module_list, false); 1134 // TODO: make event data that packages up the module_list 1135 BroadcastEvent (eBroadcastBitModulesUnloaded, NULL); 1136 } 1137 } 1138 1139 bool 1140 Target::ModuleIsExcludedForNonModuleSpecificSearches (const FileSpec &module_file_spec) 1141 { 1142 if (GetBreakpointsConsultPlatformAvoidList()) 1143 { 1144 ModuleList matchingModules; 1145 ModuleSpec module_spec (module_file_spec); 1146 size_t num_modules = GetImages().FindModules(module_spec, matchingModules); 1147 1148 // If there is more than one module for this file spec, only return true if ALL the modules are on the 1149 // black list. 1150 if (num_modules > 0) 1151 { 1152 for (int i = 0; i < num_modules; i++) 1153 { 1154 if (!ModuleIsExcludedForNonModuleSpecificSearches (matchingModules.GetModuleAtIndex(i))) 1155 return false; 1156 } 1157 return true; 1158 } 1159 } 1160 return false; 1161 } 1162 1163 bool 1164 Target::ModuleIsExcludedForNonModuleSpecificSearches (const lldb::ModuleSP &module_sp) 1165 { 1166 if (GetBreakpointsConsultPlatformAvoidList()) 1167 { 1168 if (m_platform_sp) 1169 return m_platform_sp->ModuleIsExcludedForNonModuleSpecificSearches (*this, module_sp); 1170 } 1171 return false; 1172 } 1173 1174 size_t 1175 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error) 1176 { 1177 SectionSP section_sp (addr.GetSection()); 1178 if (section_sp) 1179 { 1180 // If the contents of this section are encrypted, the on-disk file is unusuable. Read only from live memory. 1181 if (section_sp->IsEncrypted()) 1182 { 1183 error.SetErrorString("section is encrypted"); 1184 return 0; 1185 } 1186 ModuleSP module_sp (section_sp->GetModule()); 1187 if (module_sp) 1188 { 1189 ObjectFile *objfile = section_sp->GetModule()->GetObjectFile(); 1190 if (objfile) 1191 { 1192 size_t bytes_read = objfile->ReadSectionData (section_sp.get(), 1193 addr.GetOffset(), 1194 dst, 1195 dst_len); 1196 if (bytes_read > 0) 1197 return bytes_read; 1198 else 1199 error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString()); 1200 } 1201 else 1202 error.SetErrorString("address isn't from a object file"); 1203 } 1204 else 1205 error.SetErrorString("address isn't in a module"); 1206 } 1207 else 1208 error.SetErrorString("address doesn't contain a section that points to a section in a object file"); 1209 1210 return 0; 1211 } 1212 1213 size_t 1214 Target::ReadMemory (const Address& addr, 1215 bool prefer_file_cache, 1216 void *dst, 1217 size_t dst_len, 1218 Error &error, 1219 lldb::addr_t *load_addr_ptr) 1220 { 1221 error.Clear(); 1222 1223 // if we end up reading this from process memory, we will fill this 1224 // with the actual load address 1225 if (load_addr_ptr) 1226 *load_addr_ptr = LLDB_INVALID_ADDRESS; 1227 1228 size_t bytes_read = 0; 1229 1230 addr_t load_addr = LLDB_INVALID_ADDRESS; 1231 addr_t file_addr = LLDB_INVALID_ADDRESS; 1232 Address resolved_addr; 1233 if (!addr.IsSectionOffset()) 1234 { 1235 if (m_section_load_list.IsEmpty()) 1236 { 1237 // No sections are loaded, so we must assume we are not running 1238 // yet and anything we are given is a file address. 1239 file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address 1240 m_images.ResolveFileAddress (file_addr, resolved_addr); 1241 } 1242 else 1243 { 1244 // We have at least one section loaded. This can be becuase 1245 // we have manually loaded some sections with "target modules load ..." 1246 // or because we have have a live process that has sections loaded 1247 // through the dynamic loader 1248 load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address 1249 m_section_load_list.ResolveLoadAddress (load_addr, resolved_addr); 1250 } 1251 } 1252 if (!resolved_addr.IsValid()) 1253 resolved_addr = addr; 1254 1255 1256 if (prefer_file_cache) 1257 { 1258 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1259 if (bytes_read > 0) 1260 return bytes_read; 1261 } 1262 1263 if (ProcessIsValid()) 1264 { 1265 if (load_addr == LLDB_INVALID_ADDRESS) 1266 load_addr = resolved_addr.GetLoadAddress (this); 1267 1268 if (load_addr == LLDB_INVALID_ADDRESS) 1269 { 1270 ModuleSP addr_module_sp (resolved_addr.GetModule()); 1271 if (addr_module_sp && addr_module_sp->GetFileSpec()) 1272 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded", 1273 addr_module_sp->GetFileSpec().GetFilename().AsCString(), 1274 resolved_addr.GetFileAddress(), 1275 addr_module_sp->GetFileSpec().GetFilename().AsCString()); 1276 else 1277 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress()); 1278 } 1279 else 1280 { 1281 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error); 1282 if (bytes_read != dst_len) 1283 { 1284 if (error.Success()) 1285 { 1286 if (bytes_read == 0) 1287 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr); 1288 else 1289 error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr); 1290 } 1291 } 1292 if (bytes_read) 1293 { 1294 if (load_addr_ptr) 1295 *load_addr_ptr = load_addr; 1296 return bytes_read; 1297 } 1298 // If the address is not section offset we have an address that 1299 // doesn't resolve to any address in any currently loaded shared 1300 // libaries and we failed to read memory so there isn't anything 1301 // more we can do. If it is section offset, we might be able to 1302 // read cached memory from the object file. 1303 if (!resolved_addr.IsSectionOffset()) 1304 return 0; 1305 } 1306 } 1307 1308 if (!prefer_file_cache && resolved_addr.IsSectionOffset()) 1309 { 1310 // If we didn't already try and read from the object file cache, then 1311 // try it after failing to read from the process. 1312 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 1313 } 1314 return 0; 1315 } 1316 1317 size_t 1318 Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error) 1319 { 1320 char buf[256]; 1321 out_str.clear(); 1322 addr_t curr_addr = addr.GetLoadAddress(this); 1323 Address address(addr); 1324 while (1) 1325 { 1326 size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error); 1327 if (length == 0) 1328 break; 1329 out_str.append(buf, length); 1330 // If we got "length - 1" bytes, we didn't get the whole C string, we 1331 // need to read some more characters 1332 if (length == sizeof(buf) - 1) 1333 curr_addr += length; 1334 else 1335 break; 1336 address = Address(curr_addr); 1337 } 1338 return out_str.size(); 1339 } 1340 1341 1342 size_t 1343 Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error) 1344 { 1345 size_t total_cstr_len = 0; 1346 if (dst && dst_max_len) 1347 { 1348 result_error.Clear(); 1349 // NULL out everything just to be safe 1350 memset (dst, 0, dst_max_len); 1351 Error error; 1352 addr_t curr_addr = addr.GetLoadAddress(this); 1353 Address address(addr); 1354 const size_t cache_line_size = 512; 1355 size_t bytes_left = dst_max_len - 1; 1356 char *curr_dst = dst; 1357 1358 while (bytes_left > 0) 1359 { 1360 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size); 1361 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left); 1362 size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error); 1363 1364 if (bytes_read == 0) 1365 { 1366 result_error = error; 1367 dst[total_cstr_len] = '\0'; 1368 break; 1369 } 1370 const size_t len = strlen(curr_dst); 1371 1372 total_cstr_len += len; 1373 1374 if (len < bytes_to_read) 1375 break; 1376 1377 curr_dst += bytes_read; 1378 curr_addr += bytes_read; 1379 bytes_left -= bytes_read; 1380 address = Address(curr_addr); 1381 } 1382 } 1383 else 1384 { 1385 if (dst == NULL) 1386 result_error.SetErrorString("invalid arguments"); 1387 else 1388 result_error.Clear(); 1389 } 1390 return total_cstr_len; 1391 } 1392 1393 size_t 1394 Target::ReadScalarIntegerFromMemory (const Address& addr, 1395 bool prefer_file_cache, 1396 uint32_t byte_size, 1397 bool is_signed, 1398 Scalar &scalar, 1399 Error &error) 1400 { 1401 uint64_t uval; 1402 1403 if (byte_size <= sizeof(uval)) 1404 { 1405 size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error); 1406 if (bytes_read == byte_size) 1407 { 1408 DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize()); 1409 lldb::offset_t offset = 0; 1410 if (byte_size <= 4) 1411 scalar = data.GetMaxU32 (&offset, byte_size); 1412 else 1413 scalar = data.GetMaxU64 (&offset, byte_size); 1414 1415 if (is_signed) 1416 scalar.SignExtend(byte_size * 8); 1417 return bytes_read; 1418 } 1419 } 1420 else 1421 { 1422 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size); 1423 } 1424 return 0; 1425 } 1426 1427 uint64_t 1428 Target::ReadUnsignedIntegerFromMemory (const Address& addr, 1429 bool prefer_file_cache, 1430 size_t integer_byte_size, 1431 uint64_t fail_value, 1432 Error &error) 1433 { 1434 Scalar scalar; 1435 if (ReadScalarIntegerFromMemory (addr, 1436 prefer_file_cache, 1437 integer_byte_size, 1438 false, 1439 scalar, 1440 error)) 1441 return scalar.ULongLong(fail_value); 1442 return fail_value; 1443 } 1444 1445 bool 1446 Target::ReadPointerFromMemory (const Address& addr, 1447 bool prefer_file_cache, 1448 Error &error, 1449 Address &pointer_addr) 1450 { 1451 Scalar scalar; 1452 if (ReadScalarIntegerFromMemory (addr, 1453 prefer_file_cache, 1454 m_arch.GetAddressByteSize(), 1455 false, 1456 scalar, 1457 error)) 1458 { 1459 addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS); 1460 if (pointer_vm_addr != LLDB_INVALID_ADDRESS) 1461 { 1462 if (m_section_load_list.IsEmpty()) 1463 { 1464 // No sections are loaded, so we must assume we are not running 1465 // yet and anything we are given is a file address. 1466 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr); 1467 } 1468 else 1469 { 1470 // We have at least one section loaded. This can be becuase 1471 // we have manually loaded some sections with "target modules load ..." 1472 // or because we have have a live process that has sections loaded 1473 // through the dynamic loader 1474 m_section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr); 1475 } 1476 // We weren't able to resolve the pointer value, so just return 1477 // an address with no section 1478 if (!pointer_addr.IsValid()) 1479 pointer_addr.SetOffset (pointer_vm_addr); 1480 return true; 1481 1482 } 1483 } 1484 return false; 1485 } 1486 1487 ModuleSP 1488 Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr) 1489 { 1490 ModuleSP module_sp; 1491 1492 Error error; 1493 1494 // First see if we already have this module in our module list. If we do, then we're done, we don't need 1495 // to consult the shared modules list. But only do this if we are passed a UUID. 1496 1497 if (module_spec.GetUUID().IsValid()) 1498 module_sp = m_images.FindFirstModule(module_spec); 1499 1500 if (!module_sp) 1501 { 1502 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library 1503 bool did_create_module = false; 1504 1505 // If there are image search path entries, try to use them first to acquire a suitable image. 1506 if (m_image_search_paths.GetSize()) 1507 { 1508 ModuleSpec transformed_spec (module_spec); 1509 if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory())) 1510 { 1511 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename(); 1512 error = ModuleList::GetSharedModule (transformed_spec, 1513 module_sp, 1514 &GetExecutableSearchPaths(), 1515 &old_module_sp, 1516 &did_create_module); 1517 } 1518 } 1519 1520 if (!module_sp) 1521 { 1522 // If we have a UUID, we can check our global shared module list in case 1523 // we already have it. If we don't have a valid UUID, then we can't since 1524 // the path in "module_spec" will be a platform path, and we will need to 1525 // let the platform find that file. For example, we could be asking for 1526 // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick 1527 // the local copy of "/usr/lib/dyld" since our platform could be a remote 1528 // platform that has its own "/usr/lib/dyld" in an SDK or in a local file 1529 // cache. 1530 if (module_spec.GetUUID().IsValid()) 1531 { 1532 // We have a UUID, it is OK to check the global module list... 1533 error = ModuleList::GetSharedModule (module_spec, 1534 module_sp, 1535 &GetExecutableSearchPaths(), 1536 &old_module_sp, 1537 &did_create_module); 1538 } 1539 1540 if (!module_sp) 1541 { 1542 // The platform is responsible for finding and caching an appropriate 1543 // module in the shared module cache. 1544 if (m_platform_sp) 1545 { 1546 FileSpec platform_file_spec; 1547 error = m_platform_sp->GetSharedModule (module_spec, 1548 module_sp, 1549 &GetExecutableSearchPaths(), 1550 &old_module_sp, 1551 &did_create_module); 1552 } 1553 else 1554 { 1555 error.SetErrorString("no platform is currently set"); 1556 } 1557 } 1558 } 1559 1560 // We found a module that wasn't in our target list. Let's make sure that there wasn't an equivalent 1561 // module in the list already, and if there was, let's remove it. 1562 if (module_sp) 1563 { 1564 ObjectFile *objfile = module_sp->GetObjectFile(); 1565 if (objfile) 1566 { 1567 switch (objfile->GetType()) 1568 { 1569 case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of a program's execution state 1570 case ObjectFile::eTypeExecutable: /// A normal executable 1571 case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable 1572 case ObjectFile::eTypeObjectFile: /// An intermediate object file 1573 case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution 1574 break; 1575 case ObjectFile::eTypeDebugInfo: /// An object file that contains only debug information 1576 if (error_ptr) 1577 error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable"); 1578 return ModuleSP(); 1579 case ObjectFile::eTypeStubLibrary: /// A library that can be linked against but not used for execution 1580 if (error_ptr) 1581 error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable"); 1582 return ModuleSP(); 1583 default: 1584 if (error_ptr) 1585 error_ptr->SetErrorString("unsupported file type, please specify an executable"); 1586 return ModuleSP(); 1587 } 1588 // GetSharedModule is not guaranteed to find the old shared module, for instance 1589 // in the common case where you pass in the UUID, it is only going to find the one 1590 // module matching the UUID. In fact, it has no good way to know what the "old module" 1591 // relevant to this target is, since there might be many copies of a module with this file spec 1592 // in various running debug sessions, but only one of them will belong to this target. 1593 // So let's remove the UUID from the module list, and look in the target's module list. 1594 // Only do this if there is SOMETHING else in the module spec... 1595 if (!old_module_sp) 1596 { 1597 if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty()) 1598 { 1599 ModuleSpec module_spec_copy(module_spec.GetFileSpec()); 1600 module_spec_copy.GetUUID().Clear(); 1601 1602 ModuleList found_modules; 1603 size_t num_found = m_images.FindModules (module_spec_copy, found_modules); 1604 if (num_found == 1) 1605 { 1606 old_module_sp = found_modules.GetModuleAtIndex(0); 1607 } 1608 } 1609 } 1610 1611 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32) 1612 { 1613 m_images.ReplaceModule(old_module_sp, module_sp); 1614 Module *old_module_ptr = old_module_sp.get(); 1615 old_module_sp.reset(); 1616 ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr); 1617 } 1618 else 1619 m_images.Append(module_sp); 1620 } 1621 } 1622 } 1623 if (error_ptr) 1624 *error_ptr = error; 1625 return module_sp; 1626 } 1627 1628 1629 TargetSP 1630 Target::CalculateTarget () 1631 { 1632 return shared_from_this(); 1633 } 1634 1635 ProcessSP 1636 Target::CalculateProcess () 1637 { 1638 return ProcessSP(); 1639 } 1640 1641 ThreadSP 1642 Target::CalculateThread () 1643 { 1644 return ThreadSP(); 1645 } 1646 1647 StackFrameSP 1648 Target::CalculateStackFrame () 1649 { 1650 return StackFrameSP(); 1651 } 1652 1653 void 1654 Target::CalculateExecutionContext (ExecutionContext &exe_ctx) 1655 { 1656 exe_ctx.Clear(); 1657 exe_ctx.SetTargetPtr(this); 1658 } 1659 1660 PathMappingList & 1661 Target::GetImageSearchPathList () 1662 { 1663 return m_image_search_paths; 1664 } 1665 1666 void 1667 Target::ImageSearchPathsChanged 1668 ( 1669 const PathMappingList &path_list, 1670 void *baton 1671 ) 1672 { 1673 Target *target = (Target *)baton; 1674 ModuleSP exe_module_sp (target->GetExecutableModule()); 1675 if (exe_module_sp) 1676 { 1677 target->m_images.Clear(); 1678 target->SetExecutableModule (exe_module_sp, true); 1679 } 1680 } 1681 1682 ClangASTContext * 1683 Target::GetScratchClangASTContext(bool create_on_demand) 1684 { 1685 // Now see if we know the target triple, and if so, create our scratch AST context: 1686 if (m_scratch_ast_context_ap.get() == NULL && m_arch.IsValid() && create_on_demand) 1687 { 1688 m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch.GetTriple().str().c_str())); 1689 m_scratch_ast_source_ap.reset (new ClangASTSource(shared_from_this())); 1690 m_scratch_ast_source_ap->InstallASTContext(m_scratch_ast_context_ap->getASTContext()); 1691 llvm::OwningPtr<clang::ExternalASTSource> proxy_ast_source(m_scratch_ast_source_ap->CreateProxy()); 1692 m_scratch_ast_context_ap->SetExternalSource(proxy_ast_source); 1693 } 1694 return m_scratch_ast_context_ap.get(); 1695 } 1696 1697 ClangASTImporter * 1698 Target::GetClangASTImporter() 1699 { 1700 ClangASTImporter *ast_importer = m_ast_importer_ap.get(); 1701 1702 if (!ast_importer) 1703 { 1704 ast_importer = new ClangASTImporter(); 1705 m_ast_importer_ap.reset(ast_importer); 1706 } 1707 1708 return ast_importer; 1709 } 1710 1711 void 1712 Target::SettingsInitialize () 1713 { 1714 Process::SettingsInitialize (); 1715 } 1716 1717 void 1718 Target::SettingsTerminate () 1719 { 1720 Process::SettingsTerminate (); 1721 } 1722 1723 FileSpecList 1724 Target::GetDefaultExecutableSearchPaths () 1725 { 1726 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1727 if (properties_sp) 1728 return properties_sp->GetExecutableSearchPaths(); 1729 return FileSpecList(); 1730 } 1731 1732 ArchSpec 1733 Target::GetDefaultArchitecture () 1734 { 1735 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1736 if (properties_sp) 1737 return properties_sp->GetDefaultArchitecture(); 1738 return ArchSpec(); 1739 } 1740 1741 void 1742 Target::SetDefaultArchitecture (const ArchSpec &arch) 1743 { 1744 TargetPropertiesSP properties_sp(Target::GetGlobalProperties()); 1745 if (properties_sp) 1746 { 1747 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str()); 1748 return properties_sp->SetDefaultArchitecture(arch); 1749 } 1750 } 1751 1752 Target * 1753 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) 1754 { 1755 // The target can either exist in the "process" of ExecutionContext, or in 1756 // the "target_sp" member of SymbolContext. This accessor helper function 1757 // will get the target from one of these locations. 1758 1759 Target *target = NULL; 1760 if (sc_ptr != NULL) 1761 target = sc_ptr->target_sp.get(); 1762 if (target == NULL && exe_ctx_ptr) 1763 target = exe_ctx_ptr->GetTargetPtr(); 1764 return target; 1765 } 1766 1767 ExecutionResults 1768 Target::EvaluateExpression 1769 ( 1770 const char *expr_cstr, 1771 StackFrame *frame, 1772 lldb::ValueObjectSP &result_valobj_sp, 1773 const EvaluateExpressionOptions& options 1774 ) 1775 { 1776 result_valobj_sp.reset(); 1777 1778 ExecutionResults execution_results = eExecutionSetupError; 1779 1780 if (expr_cstr == NULL || expr_cstr[0] == '\0') 1781 return execution_results; 1782 1783 // We shouldn't run stop hooks in expressions. 1784 // Be sure to reset this if you return anywhere within this function. 1785 bool old_suppress_value = m_suppress_stop_hooks; 1786 m_suppress_stop_hooks = true; 1787 1788 ExecutionContext exe_ctx; 1789 1790 if (frame) 1791 { 1792 frame->CalculateExecutionContext(exe_ctx); 1793 } 1794 else if (m_process_sp) 1795 { 1796 m_process_sp->CalculateExecutionContext(exe_ctx); 1797 } 1798 else 1799 { 1800 CalculateExecutionContext(exe_ctx); 1801 } 1802 1803 // Make sure we aren't just trying to see the value of a persistent 1804 // variable (something like "$0") 1805 lldb::ClangExpressionVariableSP persistent_var_sp; 1806 // Only check for persistent variables the expression starts with a '$' 1807 if (expr_cstr[0] == '$') 1808 persistent_var_sp = m_persistent_variables.GetVariable (expr_cstr); 1809 1810 if (persistent_var_sp) 1811 { 1812 result_valobj_sp = persistent_var_sp->GetValueObject (); 1813 execution_results = eExecutionCompleted; 1814 } 1815 else 1816 { 1817 const char *prefix = GetExpressionPrefixContentsAsCString(); 1818 1819 execution_results = ClangUserExpression::Evaluate (exe_ctx, 1820 options.GetExecutionPolicy(), 1821 lldb::eLanguageTypeUnknown, 1822 options.DoesCoerceToId() ? ClangUserExpression::eResultTypeId : ClangUserExpression::eResultTypeAny, 1823 options.DoesUnwindOnError(), 1824 options.DoesIgnoreBreakpoints(), 1825 expr_cstr, 1826 prefix, 1827 result_valobj_sp, 1828 options.GetRunOthers(), 1829 options.GetTimeoutUsec()); 1830 } 1831 1832 m_suppress_stop_hooks = old_suppress_value; 1833 1834 return execution_results; 1835 } 1836 1837 lldb::addr_t 1838 Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 1839 { 1840 addr_t code_addr = load_addr; 1841 switch (m_arch.GetMachine()) 1842 { 1843 case llvm::Triple::arm: 1844 case llvm::Triple::thumb: 1845 switch (addr_class) 1846 { 1847 case eAddressClassData: 1848 case eAddressClassDebug: 1849 return LLDB_INVALID_ADDRESS; 1850 1851 case eAddressClassUnknown: 1852 case eAddressClassInvalid: 1853 case eAddressClassCode: 1854 case eAddressClassCodeAlternateISA: 1855 case eAddressClassRuntime: 1856 // Check if bit zero it no set? 1857 if ((code_addr & 1ull) == 0) 1858 { 1859 // Bit zero isn't set, check if the address is a multiple of 2? 1860 if (code_addr & 2ull) 1861 { 1862 // The address is a multiple of 2 so it must be thumb, set bit zero 1863 code_addr |= 1ull; 1864 } 1865 else if (addr_class == eAddressClassCodeAlternateISA) 1866 { 1867 // We checked the address and the address claims to be the alternate ISA 1868 // which means thumb, so set bit zero. 1869 code_addr |= 1ull; 1870 } 1871 } 1872 break; 1873 } 1874 break; 1875 1876 default: 1877 break; 1878 } 1879 return code_addr; 1880 } 1881 1882 lldb::addr_t 1883 Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const 1884 { 1885 addr_t opcode_addr = load_addr; 1886 switch (m_arch.GetMachine()) 1887 { 1888 case llvm::Triple::arm: 1889 case llvm::Triple::thumb: 1890 switch (addr_class) 1891 { 1892 case eAddressClassData: 1893 case eAddressClassDebug: 1894 return LLDB_INVALID_ADDRESS; 1895 1896 case eAddressClassInvalid: 1897 case eAddressClassUnknown: 1898 case eAddressClassCode: 1899 case eAddressClassCodeAlternateISA: 1900 case eAddressClassRuntime: 1901 opcode_addr &= ~(1ull); 1902 break; 1903 } 1904 break; 1905 1906 default: 1907 break; 1908 } 1909 return opcode_addr; 1910 } 1911 1912 SourceManager & 1913 Target::GetSourceManager () 1914 { 1915 if (m_source_manager_ap.get() == NULL) 1916 m_source_manager_ap.reset (new SourceManager(shared_from_this())); 1917 return *m_source_manager_ap; 1918 } 1919 1920 1921 lldb::user_id_t 1922 Target::AddStopHook (Target::StopHookSP &new_hook_sp) 1923 { 1924 lldb::user_id_t new_uid = ++m_stop_hook_next_id; 1925 new_hook_sp.reset (new StopHook(shared_from_this(), new_uid)); 1926 m_stop_hooks[new_uid] = new_hook_sp; 1927 return new_uid; 1928 } 1929 1930 bool 1931 Target::RemoveStopHookByID (lldb::user_id_t user_id) 1932 { 1933 size_t num_removed; 1934 num_removed = m_stop_hooks.erase (user_id); 1935 if (num_removed == 0) 1936 return false; 1937 else 1938 return true; 1939 } 1940 1941 void 1942 Target::RemoveAllStopHooks () 1943 { 1944 m_stop_hooks.clear(); 1945 } 1946 1947 Target::StopHookSP 1948 Target::GetStopHookByID (lldb::user_id_t user_id) 1949 { 1950 StopHookSP found_hook; 1951 1952 StopHookCollection::iterator specified_hook_iter; 1953 specified_hook_iter = m_stop_hooks.find (user_id); 1954 if (specified_hook_iter != m_stop_hooks.end()) 1955 found_hook = (*specified_hook_iter).second; 1956 return found_hook; 1957 } 1958 1959 bool 1960 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state) 1961 { 1962 StopHookCollection::iterator specified_hook_iter; 1963 specified_hook_iter = m_stop_hooks.find (user_id); 1964 if (specified_hook_iter == m_stop_hooks.end()) 1965 return false; 1966 1967 (*specified_hook_iter).second->SetIsActive (active_state); 1968 return true; 1969 } 1970 1971 void 1972 Target::SetAllStopHooksActiveState (bool active_state) 1973 { 1974 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 1975 for (pos = m_stop_hooks.begin(); pos != end; pos++) 1976 { 1977 (*pos).second->SetIsActive (active_state); 1978 } 1979 } 1980 1981 void 1982 Target::RunStopHooks () 1983 { 1984 if (m_suppress_stop_hooks) 1985 return; 1986 1987 if (!m_process_sp) 1988 return; 1989 1990 // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression 1991 // since in that case we do not want to run the stop-hooks 1992 if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression()) 1993 return; 1994 1995 if (m_stop_hooks.empty()) 1996 return; 1997 1998 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 1999 2000 // If there aren't any active stop hooks, don't bother either: 2001 bool any_active_hooks = false; 2002 for (pos = m_stop_hooks.begin(); pos != end; pos++) 2003 { 2004 if ((*pos).second->IsActive()) 2005 { 2006 any_active_hooks = true; 2007 break; 2008 } 2009 } 2010 if (!any_active_hooks) 2011 return; 2012 2013 CommandReturnObject result; 2014 2015 std::vector<ExecutionContext> exc_ctx_with_reasons; 2016 std::vector<SymbolContext> sym_ctx_with_reasons; 2017 2018 ThreadList &cur_threadlist = m_process_sp->GetThreadList(); 2019 size_t num_threads = cur_threadlist.GetSize(); 2020 for (size_t i = 0; i < num_threads; i++) 2021 { 2022 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i); 2023 if (cur_thread_sp->ThreadStoppedForAReason()) 2024 { 2025 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0); 2026 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get())); 2027 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything)); 2028 } 2029 } 2030 2031 // If no threads stopped for a reason, don't run the stop-hooks. 2032 size_t num_exe_ctx = exc_ctx_with_reasons.size(); 2033 if (num_exe_ctx == 0) 2034 return; 2035 2036 result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream()); 2037 result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream()); 2038 2039 bool keep_going = true; 2040 bool hooks_ran = false; 2041 bool print_hook_header; 2042 bool print_thread_header; 2043 2044 if (num_exe_ctx == 1) 2045 print_thread_header = false; 2046 else 2047 print_thread_header = true; 2048 2049 if (m_stop_hooks.size() == 1) 2050 print_hook_header = false; 2051 else 2052 print_hook_header = true; 2053 2054 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) 2055 { 2056 // result.Clear(); 2057 StopHookSP cur_hook_sp = (*pos).second; 2058 if (!cur_hook_sp->IsActive()) 2059 continue; 2060 2061 bool any_thread_matched = false; 2062 for (size_t i = 0; keep_going && i < num_exe_ctx; i++) 2063 { 2064 if ((cur_hook_sp->GetSpecifier () == NULL 2065 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i])) 2066 && (cur_hook_sp->GetThreadSpecifier() == NULL 2067 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef()))) 2068 { 2069 if (!hooks_ran) 2070 { 2071 hooks_ran = true; 2072 } 2073 if (print_hook_header && !any_thread_matched) 2074 { 2075 const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ? 2076 cur_hook_sp->GetCommands().GetStringAtIndex(0) : 2077 NULL); 2078 if (cmd) 2079 result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd); 2080 else 2081 result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID()); 2082 any_thread_matched = true; 2083 } 2084 2085 if (print_thread_header) 2086 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID()); 2087 2088 bool stop_on_continue = true; 2089 bool stop_on_error = true; 2090 bool echo_commands = false; 2091 bool print_results = true; 2092 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(), 2093 &exc_ctx_with_reasons[i], 2094 stop_on_continue, 2095 stop_on_error, 2096 echo_commands, 2097 print_results, 2098 eLazyBoolNo, 2099 result); 2100 2101 // If the command started the target going again, we should bag out of 2102 // running the stop hooks. 2103 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) || 2104 (result.GetStatus() == eReturnStatusSuccessContinuingResult)) 2105 { 2106 result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID()); 2107 keep_going = false; 2108 } 2109 } 2110 } 2111 } 2112 2113 result.GetImmediateOutputStream()->Flush(); 2114 result.GetImmediateErrorStream()->Flush(); 2115 } 2116 2117 2118 //-------------------------------------------------------------- 2119 // class Target::StopHook 2120 //-------------------------------------------------------------- 2121 2122 2123 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : 2124 UserID (uid), 2125 m_target_sp (target_sp), 2126 m_commands (), 2127 m_specifier_sp (), 2128 m_thread_spec_ap(NULL), 2129 m_active (true) 2130 { 2131 } 2132 2133 Target::StopHook::StopHook (const StopHook &rhs) : 2134 UserID (rhs.GetID()), 2135 m_target_sp (rhs.m_target_sp), 2136 m_commands (rhs.m_commands), 2137 m_specifier_sp (rhs.m_specifier_sp), 2138 m_thread_spec_ap (NULL), 2139 m_active (rhs.m_active) 2140 { 2141 if (rhs.m_thread_spec_ap.get() != NULL) 2142 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); 2143 } 2144 2145 2146 Target::StopHook::~StopHook () 2147 { 2148 } 2149 2150 void 2151 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) 2152 { 2153 m_thread_spec_ap.reset (specifier); 2154 } 2155 2156 2157 void 2158 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const 2159 { 2160 int indent_level = s->GetIndentLevel(); 2161 2162 s->SetIndentLevel(indent_level + 2); 2163 2164 s->Printf ("Hook: %" PRIu64 "\n", GetID()); 2165 if (m_active) 2166 s->Indent ("State: enabled\n"); 2167 else 2168 s->Indent ("State: disabled\n"); 2169 2170 if (m_specifier_sp) 2171 { 2172 s->Indent(); 2173 s->PutCString ("Specifier:\n"); 2174 s->SetIndentLevel (indent_level + 4); 2175 m_specifier_sp->GetDescription (s, level); 2176 s->SetIndentLevel (indent_level + 2); 2177 } 2178 2179 if (m_thread_spec_ap.get() != NULL) 2180 { 2181 StreamString tmp; 2182 s->Indent("Thread:\n"); 2183 m_thread_spec_ap->GetDescription (&tmp, level); 2184 s->SetIndentLevel (indent_level + 4); 2185 s->Indent (tmp.GetData()); 2186 s->PutCString ("\n"); 2187 s->SetIndentLevel (indent_level + 2); 2188 } 2189 2190 s->Indent ("Commands: \n"); 2191 s->SetIndentLevel (indent_level + 4); 2192 uint32_t num_commands = m_commands.GetSize(); 2193 for (uint32_t i = 0; i < num_commands; i++) 2194 { 2195 s->Indent(m_commands.GetStringAtIndex(i)); 2196 s->PutCString ("\n"); 2197 } 2198 s->SetIndentLevel (indent_level); 2199 } 2200 2201 //-------------------------------------------------------------- 2202 // class TargetProperties 2203 //-------------------------------------------------------------- 2204 2205 OptionEnumValueElement 2206 lldb_private::g_dynamic_value_types[] = 2207 { 2208 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"}, 2209 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."}, 2210 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."}, 2211 { 0, NULL, NULL } 2212 }; 2213 2214 static OptionEnumValueElement 2215 g_inline_breakpoint_enums[] = 2216 { 2217 { 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."}, 2218 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."}, 2219 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."}, 2220 { 0, NULL, NULL } 2221 }; 2222 2223 typedef enum x86DisassemblyFlavor 2224 { 2225 eX86DisFlavorDefault, 2226 eX86DisFlavorIntel, 2227 eX86DisFlavorATT 2228 } x86DisassemblyFlavor; 2229 2230 static OptionEnumValueElement 2231 g_x86_dis_flavor_value_types[] = 2232 { 2233 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."}, 2234 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."}, 2235 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."}, 2236 { 0, NULL, NULL } 2237 }; 2238 2239 static PropertyDefinition 2240 g_properties[] = 2241 { 2242 { "default-arch" , OptionValue::eTypeArch , true , 0 , NULL, NULL, "Default architecture to choose, when there's a choice." }, 2243 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "Path to a file containing expressions to be prepended to all expressions." }, 2244 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eNoDynamicValues , NULL, g_dynamic_value_types, "Should printed values be shown as their dynamic value." }, 2245 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Should synthetic values be used by default whenever available." }, 2246 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Skip function prologues when setting breakpoints by name." }, 2247 { "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 " 2248 "where it exists on the current system. It consists of an array of duples, the first element of each duple is " 2249 "some part (starting at the root) of the path to the file when it was built, " 2250 "and the second is where the remainder of the original build hierarchy is rooted on the local system. " 2251 "Each element of the array is checked in order and the first one that results in a match wins." }, 2252 { "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." }, 2253 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , NULL, NULL, "Maximum number of children to expand in any level of depth." }, 2254 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of characters to show when using %s in summary strings." }, 2255 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , NULL, NULL, "Consult the platform module avoid list when setting non-module specific breakpoints." }, 2256 { "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." }, 2257 { "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." }, 2258 { "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." }, 2259 { "inherit-env" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Inherit the environment from the process that is running LLDB." }, 2260 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for reading its standard input." }, 2261 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard output." }, 2262 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard error." }, 2263 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Disable Address Space Layout Randomization (ASLR)" }, 2264 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , NULL, NULL, "Disable stdin/stdout for process (e.g. for a GUI application)" }, 2265 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsHeaders , NULL, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. " 2266 "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. " 2267 "Usually this is limitted to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. " 2268 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. " 2269 "Always checking for inlined breakpoint locations can be expensive (memory and time), so we try to minimize the " 2270 "times we look for inlined locations. This setting allows you to control exactly which strategy is used when settings " 2271 "file and line breakpoints." }, 2272 // 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. 2273 { "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." }, 2274 { "use-fast-stepping" , OptionValue::eTypeBoolean , false, false, NULL, NULL, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping." }, 2275 { NULL , OptionValue::eTypeInvalid , false, 0 , NULL, NULL, NULL } 2276 }; 2277 enum 2278 { 2279 ePropertyDefaultArch, 2280 ePropertyExprPrefix, 2281 ePropertyPreferDynamic, 2282 ePropertyEnableSynthetic, 2283 ePropertySkipPrologue, 2284 ePropertySourceMap, 2285 ePropertyExecutableSearchPaths, 2286 ePropertyMaxChildrenCount, 2287 ePropertyMaxSummaryLength, 2288 ePropertyBreakpointUseAvoidList, 2289 ePropertyArg0, 2290 ePropertyRunArgs, 2291 ePropertyEnvVars, 2292 ePropertyInheritEnv, 2293 ePropertyInputPath, 2294 ePropertyOutputPath, 2295 ePropertyErrorPath, 2296 ePropertyDisableASLR, 2297 ePropertyDisableSTDIO, 2298 ePropertyInlineStrategy, 2299 ePropertyDisassemblyFlavor, 2300 ePropertyUseFastStepping 2301 }; 2302 2303 2304 class TargetOptionValueProperties : public OptionValueProperties 2305 { 2306 public: 2307 TargetOptionValueProperties (const ConstString &name) : 2308 OptionValueProperties (name), 2309 m_target (NULL), 2310 m_got_host_env (false) 2311 { 2312 } 2313 2314 // This constructor is used when creating TargetOptionValueProperties when it 2315 // is part of a new lldb_private::Target instance. It will copy all current 2316 // global property values as needed 2317 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) : 2318 OptionValueProperties(*target_properties_sp->GetValueProperties()), 2319 m_target (target), 2320 m_got_host_env (false) 2321 { 2322 } 2323 2324 virtual const Property * 2325 GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const 2326 { 2327 // When gettings the value for a key from the target options, we will always 2328 // try and grab the setting from the current target if there is one. Else we just 2329 // use the one from this instance. 2330 if (idx == ePropertyEnvVars) 2331 GetHostEnvironmentIfNeeded (); 2332 2333 if (exe_ctx) 2334 { 2335 Target *target = exe_ctx->GetTargetPtr(); 2336 if (target) 2337 { 2338 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get()); 2339 if (this != target_properties) 2340 return target_properties->ProtectedGetPropertyAtIndex (idx); 2341 } 2342 } 2343 return ProtectedGetPropertyAtIndex (idx); 2344 } 2345 protected: 2346 2347 void 2348 GetHostEnvironmentIfNeeded () const 2349 { 2350 if (!m_got_host_env) 2351 { 2352 if (m_target) 2353 { 2354 m_got_host_env = true; 2355 const uint32_t idx = ePropertyInheritEnv; 2356 if (GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0)) 2357 { 2358 PlatformSP platform_sp (m_target->GetPlatform()); 2359 if (platform_sp) 2360 { 2361 StringList env; 2362 if (platform_sp->GetEnvironment(env)) 2363 { 2364 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary (NULL, ePropertyEnvVars); 2365 if (env_dict) 2366 { 2367 const bool can_replace = false; 2368 const size_t envc = env.GetSize(); 2369 for (size_t idx=0; idx<envc; idx++) 2370 { 2371 const char *env_entry = env.GetStringAtIndex (idx); 2372 if (env_entry) 2373 { 2374 const char *equal_pos = ::strchr(env_entry, '='); 2375 ConstString key; 2376 // It is ok to have environment variables with no values 2377 const char *value = NULL; 2378 if (equal_pos) 2379 { 2380 key.SetCStringWithLength(env_entry, equal_pos - env_entry); 2381 if (equal_pos[1]) 2382 value = equal_pos + 1; 2383 } 2384 else 2385 { 2386 key.SetCString(env_entry); 2387 } 2388 // Don't allow existing keys to be replaced with ones we get from the platform environment 2389 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace); 2390 } 2391 } 2392 } 2393 } 2394 } 2395 } 2396 } 2397 } 2398 } 2399 Target *m_target; 2400 mutable bool m_got_host_env; 2401 }; 2402 2403 TargetProperties::TargetProperties (Target *target) : 2404 Properties () 2405 { 2406 if (target) 2407 { 2408 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties())); 2409 } 2410 else 2411 { 2412 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target"))); 2413 m_collection_sp->Initialize(g_properties); 2414 m_collection_sp->AppendProperty(ConstString("process"), 2415 ConstString("Settings specify to processes."), 2416 true, 2417 Process::GetGlobalProperties()->GetValueProperties()); 2418 } 2419 } 2420 2421 TargetProperties::~TargetProperties () 2422 { 2423 } 2424 ArchSpec 2425 TargetProperties::GetDefaultArchitecture () const 2426 { 2427 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch); 2428 if (value) 2429 return value->GetCurrentValue(); 2430 return ArchSpec(); 2431 } 2432 2433 void 2434 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch) 2435 { 2436 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch); 2437 if (value) 2438 return value->SetCurrentValue(arch, true); 2439 } 2440 2441 lldb::DynamicValueType 2442 TargetProperties::GetPreferDynamicValue() const 2443 { 2444 const uint32_t idx = ePropertyPreferDynamic; 2445 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 2446 } 2447 2448 bool 2449 TargetProperties::GetDisableASLR () const 2450 { 2451 const uint32_t idx = ePropertyDisableASLR; 2452 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2453 } 2454 2455 void 2456 TargetProperties::SetDisableASLR (bool b) 2457 { 2458 const uint32_t idx = ePropertyDisableASLR; 2459 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 2460 } 2461 2462 bool 2463 TargetProperties::GetDisableSTDIO () const 2464 { 2465 const uint32_t idx = ePropertyDisableSTDIO; 2466 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2467 } 2468 2469 void 2470 TargetProperties::SetDisableSTDIO (bool b) 2471 { 2472 const uint32_t idx = ePropertyDisableSTDIO; 2473 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b); 2474 } 2475 2476 const char * 2477 TargetProperties::GetDisassemblyFlavor () const 2478 { 2479 const uint32_t idx = ePropertyDisassemblyFlavor; 2480 const char *return_value; 2481 2482 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 2483 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value; 2484 return return_value; 2485 } 2486 2487 InlineStrategy 2488 TargetProperties::GetInlineStrategy () const 2489 { 2490 const uint32_t idx = ePropertyInlineStrategy; 2491 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value); 2492 } 2493 2494 const char * 2495 TargetProperties::GetArg0 () const 2496 { 2497 const uint32_t idx = ePropertyArg0; 2498 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, NULL); 2499 } 2500 2501 void 2502 TargetProperties::SetArg0 (const char *arg) 2503 { 2504 const uint32_t idx = ePropertyArg0; 2505 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, arg); 2506 } 2507 2508 bool 2509 TargetProperties::GetRunArguments (Args &args) const 2510 { 2511 const uint32_t idx = ePropertyRunArgs; 2512 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, args); 2513 } 2514 2515 void 2516 TargetProperties::SetRunArguments (const Args &args) 2517 { 2518 const uint32_t idx = ePropertyRunArgs; 2519 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, args); 2520 } 2521 2522 size_t 2523 TargetProperties::GetEnvironmentAsArgs (Args &env) const 2524 { 2525 const uint32_t idx = ePropertyEnvVars; 2526 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, env); 2527 } 2528 2529 bool 2530 TargetProperties::GetSkipPrologue() const 2531 { 2532 const uint32_t idx = ePropertySkipPrologue; 2533 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2534 } 2535 2536 PathMappingList & 2537 TargetProperties::GetSourcePathMap () const 2538 { 2539 const uint32_t idx = ePropertySourceMap; 2540 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings (NULL, false, idx); 2541 assert(option_value); 2542 return option_value->GetCurrentValue(); 2543 } 2544 2545 FileSpecList & 2546 TargetProperties::GetExecutableSearchPaths () 2547 { 2548 const uint32_t idx = ePropertyExecutableSearchPaths; 2549 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx); 2550 assert(option_value); 2551 return option_value->GetCurrentValue(); 2552 } 2553 2554 bool 2555 TargetProperties::GetEnableSyntheticValue () const 2556 { 2557 const uint32_t idx = ePropertyEnableSynthetic; 2558 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2559 } 2560 2561 uint32_t 2562 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const 2563 { 2564 const uint32_t idx = ePropertyMaxChildrenCount; 2565 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 2566 } 2567 2568 uint32_t 2569 TargetProperties::GetMaximumSizeOfStringSummary() const 2570 { 2571 const uint32_t idx = ePropertyMaxSummaryLength; 2572 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value); 2573 } 2574 2575 FileSpec 2576 TargetProperties::GetStandardInputPath () const 2577 { 2578 const uint32_t idx = ePropertyInputPath; 2579 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 2580 } 2581 2582 void 2583 TargetProperties::SetStandardInputPath (const char *p) 2584 { 2585 const uint32_t idx = ePropertyInputPath; 2586 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 2587 } 2588 2589 FileSpec 2590 TargetProperties::GetStandardOutputPath () const 2591 { 2592 const uint32_t idx = ePropertyOutputPath; 2593 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 2594 } 2595 2596 void 2597 TargetProperties::SetStandardOutputPath (const char *p) 2598 { 2599 const uint32_t idx = ePropertyOutputPath; 2600 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 2601 } 2602 2603 FileSpec 2604 TargetProperties::GetStandardErrorPath () const 2605 { 2606 const uint32_t idx = ePropertyErrorPath; 2607 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx); 2608 } 2609 2610 const char * 2611 TargetProperties::GetExpressionPrefixContentsAsCString () 2612 { 2613 const uint32_t idx = ePropertyExprPrefix; 2614 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec (NULL, false, idx); 2615 if (file) 2616 { 2617 const bool null_terminate = true; 2618 DataBufferSP data_sp(file->GetFileContents(null_terminate)); 2619 if (data_sp) 2620 return (const char *) data_sp->GetBytes(); 2621 } 2622 return NULL; 2623 } 2624 2625 void 2626 TargetProperties::SetStandardErrorPath (const char *p) 2627 { 2628 const uint32_t idx = ePropertyErrorPath; 2629 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p); 2630 } 2631 2632 bool 2633 TargetProperties::GetBreakpointsConsultPlatformAvoidList () 2634 { 2635 const uint32_t idx = ePropertyBreakpointUseAvoidList; 2636 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2637 } 2638 2639 bool 2640 TargetProperties::GetUseFastStepping () const 2641 { 2642 const uint32_t idx = ePropertyUseFastStepping; 2643 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 2644 } 2645 2646 const TargetPropertiesSP & 2647 Target::GetGlobalProperties() 2648 { 2649 static TargetPropertiesSP g_settings_sp; 2650 if (!g_settings_sp) 2651 { 2652 g_settings_sp.reset (new TargetProperties (NULL)); 2653 } 2654 return g_settings_sp; 2655 } 2656 2657 const ConstString & 2658 Target::TargetEventData::GetFlavorString () 2659 { 2660 static ConstString g_flavor ("Target::TargetEventData"); 2661 return g_flavor; 2662 } 2663 2664 const ConstString & 2665 Target::TargetEventData::GetFlavor () const 2666 { 2667 return TargetEventData::GetFlavorString (); 2668 } 2669 2670 Target::TargetEventData::TargetEventData (const lldb::TargetSP &new_target_sp) : 2671 EventData(), 2672 m_target_sp (new_target_sp) 2673 { 2674 } 2675 2676 Target::TargetEventData::~TargetEventData() 2677 { 2678 2679 } 2680 2681 void 2682 Target::TargetEventData::Dump (Stream *s) const 2683 { 2684 2685 } 2686 2687 const TargetSP 2688 Target::TargetEventData::GetTargetFromEvent (const lldb::EventSP &event_sp) 2689 { 2690 TargetSP target_sp; 2691 2692 const TargetEventData *data = GetEventDataFromEvent (event_sp.get()); 2693 if (data) 2694 target_sp = data->m_target_sp; 2695 2696 return target_sp; 2697 } 2698 2699 const Target::TargetEventData * 2700 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr) 2701 { 2702 if (event_ptr) 2703 { 2704 const EventData *event_data = event_ptr->GetData(); 2705 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString()) 2706 return static_cast <const TargetEventData *> (event_ptr->GetData()); 2707 } 2708 return NULL; 2709 } 2710 2711