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