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/BreakpointResolverName.h" 20 #include "lldb/Core/Debugger.h" 21 #include "lldb/Core/Event.h" 22 #include "lldb/Core/Log.h" 23 #include "lldb/Core/StreamString.h" 24 #include "lldb/Core/Timer.h" 25 #include "lldb/Core/ValueObject.h" 26 #include "lldb/Expression/ClangUserExpression.h" 27 #include "lldb/Host/Host.h" 28 #include "lldb/Interpreter/CommandInterpreter.h" 29 #include "lldb/Interpreter/CommandReturnObject.h" 30 #include "lldb/lldb-private-log.h" 31 #include "lldb/Symbol/ObjectFile.h" 32 #include "lldb/Target/Process.h" 33 #include "lldb/Target/StackFrame.h" 34 #include "lldb/Target/Thread.h" 35 #include "lldb/Target/ThreadSpec.h" 36 37 using namespace lldb; 38 using namespace lldb_private; 39 40 //---------------------------------------------------------------------- 41 // Target constructor 42 //---------------------------------------------------------------------- 43 Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp) : 44 Broadcaster ("lldb.target"), 45 ExecutionContextScope (), 46 TargetInstanceSettings (*GetSettingsController()), 47 m_debugger (debugger), 48 m_platform_sp (platform_sp), 49 m_mutex (Mutex::eMutexTypeRecursive), 50 m_arch (target_arch), 51 m_images (), 52 m_section_load_list (), 53 m_breakpoint_list (false), 54 m_internal_breakpoint_list (true), 55 m_process_sp (), 56 m_search_filter_sp (), 57 m_image_search_paths (ImageSearchPathsChanged, this), 58 m_scratch_ast_context_ap (NULL), 59 m_persistent_variables (), 60 m_stop_hooks (), 61 m_stop_hook_next_id (0) 62 { 63 SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed"); 64 SetEventName (eBroadcastBitModulesLoaded, "modules-loaded"); 65 SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded"); 66 67 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 68 if (log) 69 log->Printf ("%p Target::Target()", this); 70 } 71 72 //---------------------------------------------------------------------- 73 // Destructor 74 //---------------------------------------------------------------------- 75 Target::~Target() 76 { 77 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 78 if (log) 79 log->Printf ("%p Target::~Target()", this); 80 DeleteCurrentProcess (); 81 } 82 83 void 84 Target::Dump (Stream *s, lldb::DescriptionLevel description_level) 85 { 86 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 87 if (description_level != lldb::eDescriptionLevelBrief) 88 { 89 s->Indent(); 90 s->PutCString("Target\n"); 91 s->IndentMore(); 92 m_images.Dump(s); 93 m_breakpoint_list.Dump(s); 94 m_internal_breakpoint_list.Dump(s); 95 s->IndentLess(); 96 } 97 else 98 { 99 s->PutCString (GetExecutableModule()->GetFileSpec().GetFilename().GetCString()); 100 } 101 } 102 103 void 104 Target::DeleteCurrentProcess () 105 { 106 if (m_process_sp.get()) 107 { 108 m_section_load_list.Clear(); 109 if (m_process_sp->IsAlive()) 110 m_process_sp->Destroy(); 111 112 m_process_sp->Finalize(); 113 114 // Do any cleanup of the target we need to do between process instances. 115 // NB It is better to do this before destroying the process in case the 116 // clean up needs some help from the process. 117 m_breakpoint_list.ClearAllBreakpointSites(); 118 m_internal_breakpoint_list.ClearAllBreakpointSites(); 119 m_process_sp.reset(); 120 } 121 } 122 123 const lldb::ProcessSP & 124 Target::CreateProcess (Listener &listener, const char *plugin_name) 125 { 126 DeleteCurrentProcess (); 127 m_process_sp.reset(Process::FindPlugin(*this, plugin_name, listener)); 128 return m_process_sp; 129 } 130 131 const lldb::ProcessSP & 132 Target::GetProcessSP () const 133 { 134 return m_process_sp; 135 } 136 137 lldb::TargetSP 138 Target::GetSP() 139 { 140 return m_debugger.GetTargetList().GetTargetSP(this); 141 } 142 143 BreakpointList & 144 Target::GetBreakpointList(bool internal) 145 { 146 if (internal) 147 return m_internal_breakpoint_list; 148 else 149 return m_breakpoint_list; 150 } 151 152 const BreakpointList & 153 Target::GetBreakpointList(bool internal) const 154 { 155 if (internal) 156 return m_internal_breakpoint_list; 157 else 158 return m_breakpoint_list; 159 } 160 161 BreakpointSP 162 Target::GetBreakpointByID (break_id_t break_id) 163 { 164 BreakpointSP bp_sp; 165 166 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 167 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 168 else 169 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 170 171 return bp_sp; 172 } 173 174 BreakpointSP 175 Target::CreateBreakpoint (const FileSpec *containingModule, const FileSpec &file, uint32_t line_no, bool check_inlines, bool internal) 176 { 177 SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); 178 BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (NULL, file, line_no, check_inlines)); 179 return CreateBreakpoint (filter_sp, resolver_sp, internal); 180 } 181 182 183 BreakpointSP 184 Target::CreateBreakpoint (lldb::addr_t addr, bool internal) 185 { 186 Address so_addr; 187 // Attempt to resolve our load address if possible, though it is ok if 188 // it doesn't resolve to section/offset. 189 190 // Try and resolve as a load address if possible 191 m_section_load_list.ResolveLoadAddress(addr, so_addr); 192 if (!so_addr.IsValid()) 193 { 194 // The address didn't resolve, so just set this as an absolute address 195 so_addr.SetOffset (addr); 196 } 197 BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal)); 198 return bp_sp; 199 } 200 201 BreakpointSP 202 Target::CreateBreakpoint (Address &addr, bool internal) 203 { 204 TargetSP target_sp = this->GetSP(); 205 SearchFilterSP filter_sp(new SearchFilter (target_sp)); 206 BreakpointResolverSP resolver_sp (new BreakpointResolverAddress (NULL, addr)); 207 return CreateBreakpoint (filter_sp, resolver_sp, internal); 208 } 209 210 BreakpointSP 211 Target::CreateBreakpoint (FileSpec *containingModule, const char *func_name, uint32_t func_name_type_mask, bool internal) 212 { 213 BreakpointSP bp_sp; 214 if (func_name) 215 { 216 SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); 217 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, func_name, func_name_type_mask, Breakpoint::Exact)); 218 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal); 219 } 220 return bp_sp; 221 } 222 223 224 SearchFilterSP 225 Target::GetSearchFilterForModule (const FileSpec *containingModule) 226 { 227 SearchFilterSP filter_sp; 228 lldb::TargetSP target_sp = this->GetSP(); 229 if (containingModule != NULL) 230 { 231 // TODO: We should look into sharing module based search filters 232 // across many breakpoints like we do for the simple target based one 233 filter_sp.reset (new SearchFilterByModule (target_sp, *containingModule)); 234 } 235 else 236 { 237 if (m_search_filter_sp.get() == NULL) 238 m_search_filter_sp.reset (new SearchFilter (target_sp)); 239 filter_sp = m_search_filter_sp; 240 } 241 return filter_sp; 242 } 243 244 BreakpointSP 245 Target::CreateBreakpoint (FileSpec *containingModule, RegularExpression &func_regex, bool internal) 246 { 247 SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); 248 BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL, func_regex)); 249 250 return CreateBreakpoint (filter_sp, resolver_sp, internal); 251 } 252 253 BreakpointSP 254 Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal) 255 { 256 BreakpointSP bp_sp; 257 if (filter_sp && resolver_sp) 258 { 259 bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp)); 260 resolver_sp->SetBreakpoint (bp_sp.get()); 261 262 if (internal) 263 m_internal_breakpoint_list.Add (bp_sp, false); 264 else 265 m_breakpoint_list.Add (bp_sp, true); 266 267 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 268 if (log) 269 { 270 StreamString s; 271 bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 272 log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, internal ? "yes" : "no", s.GetData()); 273 } 274 275 bp_sp->ResolveBreakpoint(); 276 } 277 278 if (!internal && bp_sp) 279 { 280 m_last_created_breakpoint = bp_sp; 281 } 282 283 return bp_sp; 284 } 285 286 void 287 Target::RemoveAllBreakpoints (bool internal_also) 288 { 289 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 290 if (log) 291 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 292 293 m_breakpoint_list.RemoveAll (true); 294 if (internal_also) 295 m_internal_breakpoint_list.RemoveAll (false); 296 297 m_last_created_breakpoint.reset(); 298 } 299 300 void 301 Target::DisableAllBreakpoints (bool internal_also) 302 { 303 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 304 if (log) 305 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 306 307 m_breakpoint_list.SetEnabledAll (false); 308 if (internal_also) 309 m_internal_breakpoint_list.SetEnabledAll (false); 310 } 311 312 void 313 Target::EnableAllBreakpoints (bool internal_also) 314 { 315 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 316 if (log) 317 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); 318 319 m_breakpoint_list.SetEnabledAll (true); 320 if (internal_also) 321 m_internal_breakpoint_list.SetEnabledAll (true); 322 } 323 324 bool 325 Target::RemoveBreakpointByID (break_id_t break_id) 326 { 327 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 328 if (log) 329 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 330 331 if (DisableBreakpointByID (break_id)) 332 { 333 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 334 m_internal_breakpoint_list.Remove(break_id, false); 335 else 336 { 337 if (m_last_created_breakpoint) 338 { 339 if (m_last_created_breakpoint->GetID() == break_id) 340 m_last_created_breakpoint.reset(); 341 } 342 m_breakpoint_list.Remove(break_id, true); 343 } 344 return true; 345 } 346 return false; 347 } 348 349 bool 350 Target::DisableBreakpointByID (break_id_t break_id) 351 { 352 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 353 if (log) 354 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 355 356 BreakpointSP bp_sp; 357 358 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 359 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 360 else 361 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 362 if (bp_sp) 363 { 364 bp_sp->SetEnabled (false); 365 return true; 366 } 367 return false; 368 } 369 370 bool 371 Target::EnableBreakpointByID (break_id_t break_id) 372 { 373 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 374 if (log) 375 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", 376 __FUNCTION__, 377 break_id, 378 LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); 379 380 BreakpointSP bp_sp; 381 382 if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) 383 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); 384 else 385 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); 386 387 if (bp_sp) 388 { 389 bp_sp->SetEnabled (true); 390 return true; 391 } 392 return false; 393 } 394 395 ModuleSP 396 Target::GetExecutableModule () 397 { 398 ModuleSP executable_sp; 399 if (m_images.GetSize() > 0) 400 executable_sp = m_images.GetModuleAtIndex(0); 401 return executable_sp; 402 } 403 404 void 405 Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files) 406 { 407 m_images.Clear(); 408 m_scratch_ast_context_ap.reset(); 409 410 if (executable_sp.get()) 411 { 412 Timer scoped_timer (__PRETTY_FUNCTION__, 413 "Target::SetExecutableModule (executable = '%s/%s')", 414 executable_sp->GetFileSpec().GetDirectory().AsCString(), 415 executable_sp->GetFileSpec().GetFilename().AsCString()); 416 417 m_images.Append(executable_sp); // The first image is our exectuable file 418 419 // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module. 420 if (!m_arch.IsValid()) 421 m_arch = executable_sp->GetArchitecture(); 422 423 FileSpecList dependent_files; 424 ObjectFile *executable_objfile = executable_sp->GetObjectFile(); 425 426 if (executable_objfile) 427 { 428 executable_objfile->GetDependentModules(dependent_files); 429 for (uint32_t i=0; i<dependent_files.GetSize(); i++) 430 { 431 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i)); 432 FileSpec platform_dependent_file_spec; 433 if (m_platform_sp) 434 m_platform_sp->GetFile (dependent_file_spec, NULL, platform_dependent_file_spec); 435 else 436 platform_dependent_file_spec = dependent_file_spec; 437 438 ModuleSP image_module_sp(GetSharedModule (platform_dependent_file_spec, 439 m_arch)); 440 if (image_module_sp.get()) 441 { 442 //image_module_sp->Dump(&s);// REMOVE THIS, DEBUG ONLY 443 ObjectFile *objfile = image_module_sp->GetObjectFile(); 444 if (objfile) 445 objfile->GetDependentModules(dependent_files); 446 } 447 } 448 } 449 450 // Now see if we know the target triple, and if so, create our scratch AST context: 451 if (m_arch.IsValid()) 452 { 453 m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch.GetTriple().str().c_str())); 454 } 455 } 456 457 UpdateInstanceName(); 458 } 459 460 461 bool 462 Target::SetArchitecture (const ArchSpec &arch_spec) 463 { 464 if (m_arch == arch_spec) 465 { 466 // If we're setting the architecture to our current architecture, we 467 // don't need to do anything. 468 return true; 469 } 470 else if (!m_arch.IsValid()) 471 { 472 // If we haven't got a valid arch spec, then we just need to set it. 473 m_arch = arch_spec; 474 return true; 475 } 476 else 477 { 478 // If we have an executable file, try to reset the executable to the desired architecture 479 m_arch = arch_spec; 480 ModuleSP executable_sp = GetExecutableModule (); 481 m_images.Clear(); 482 m_scratch_ast_context_ap.reset(); 483 // Need to do something about unsetting breakpoints. 484 485 if (executable_sp) 486 { 487 FileSpec exec_file_spec = executable_sp->GetFileSpec(); 488 Error error = ModuleList::GetSharedModule(exec_file_spec, 489 arch_spec, 490 NULL, 491 NULL, 492 0, 493 executable_sp, 494 NULL, 495 NULL); 496 497 if (!error.Fail() && executable_sp) 498 { 499 SetExecutableModule (executable_sp, true); 500 return true; 501 } 502 else 503 { 504 return false; 505 } 506 } 507 else 508 { 509 return false; 510 } 511 } 512 } 513 514 void 515 Target::ModuleAdded (ModuleSP &module_sp) 516 { 517 // A module is being added to this target for the first time 518 ModuleList module_list; 519 module_list.Append(module_sp); 520 ModulesDidLoad (module_list); 521 } 522 523 void 524 Target::ModuleUpdated (ModuleSP &old_module_sp, ModuleSP &new_module_sp) 525 { 526 // A module is being added to this target for the first time 527 ModuleList module_list; 528 module_list.Append (old_module_sp); 529 ModulesDidUnload (module_list); 530 module_list.Clear (); 531 module_list.Append (new_module_sp); 532 ModulesDidLoad (module_list); 533 } 534 535 void 536 Target::ModulesDidLoad (ModuleList &module_list) 537 { 538 m_breakpoint_list.UpdateBreakpoints (module_list, true); 539 // TODO: make event data that packages up the module_list 540 BroadcastEvent (eBroadcastBitModulesLoaded, NULL); 541 } 542 543 void 544 Target::ModulesDidUnload (ModuleList &module_list) 545 { 546 m_breakpoint_list.UpdateBreakpoints (module_list, false); 547 548 // Remove the images from the target image list 549 m_images.Remove(module_list); 550 551 // TODO: make event data that packages up the module_list 552 BroadcastEvent (eBroadcastBitModulesUnloaded, NULL); 553 } 554 555 size_t 556 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error) 557 { 558 const Section *section = addr.GetSection(); 559 if (section && section->GetModule()) 560 { 561 ObjectFile *objfile = section->GetModule()->GetObjectFile(); 562 if (objfile) 563 { 564 size_t bytes_read = section->ReadSectionDataFromObjectFile (objfile, 565 addr.GetOffset(), 566 dst, 567 dst_len); 568 if (bytes_read > 0) 569 return bytes_read; 570 else 571 error.SetErrorStringWithFormat("error reading data from section %s", section->GetName().GetCString()); 572 } 573 else 574 { 575 error.SetErrorString("address isn't from a object file"); 576 } 577 } 578 else 579 { 580 error.SetErrorString("address doesn't contain a section that points to a section in a object file"); 581 } 582 return 0; 583 } 584 585 size_t 586 Target::ReadMemory (const Address& addr, bool prefer_file_cache, void *dst, size_t dst_len, Error &error) 587 { 588 error.Clear(); 589 590 bool process_is_valid = m_process_sp && m_process_sp->IsAlive(); 591 592 size_t bytes_read = 0; 593 Address resolved_addr; 594 if (!addr.IsSectionOffset()) 595 { 596 if (process_is_valid) 597 m_section_load_list.ResolveLoadAddress (addr.GetOffset(), resolved_addr); 598 else 599 m_images.ResolveFileAddress(addr.GetOffset(), resolved_addr); 600 } 601 if (!resolved_addr.IsValid()) 602 resolved_addr = addr; 603 604 if (prefer_file_cache) 605 { 606 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 607 if (bytes_read > 0) 608 return bytes_read; 609 } 610 611 if (process_is_valid) 612 { 613 lldb::addr_t load_addr = resolved_addr.GetLoadAddress (this); 614 if (load_addr == LLDB_INVALID_ADDRESS) 615 { 616 if (resolved_addr.GetModule() && resolved_addr.GetModule()->GetFileSpec()) 617 error.SetErrorStringWithFormat("%s[0x%llx] can't be resolved, %s in not currently loaded.\n", 618 resolved_addr.GetModule()->GetFileSpec().GetFilename().AsCString(), 619 resolved_addr.GetFileAddress()); 620 else 621 error.SetErrorStringWithFormat("0x%llx can't be resolved.\n", resolved_addr.GetFileAddress()); 622 } 623 else 624 { 625 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error); 626 if (bytes_read != dst_len) 627 { 628 if (error.Success()) 629 { 630 if (bytes_read == 0) 631 error.SetErrorStringWithFormat("Read memory from 0x%llx failed.\n", load_addr); 632 else 633 error.SetErrorStringWithFormat("Only %zu of %zu bytes were read from memory at 0x%llx.\n", bytes_read, dst_len, load_addr); 634 } 635 } 636 if (bytes_read) 637 return bytes_read; 638 // If the address is not section offset we have an address that 639 // doesn't resolve to any address in any currently loaded shared 640 // libaries and we failed to read memory so there isn't anything 641 // more we can do. If it is section offset, we might be able to 642 // read cached memory from the object file. 643 if (!resolved_addr.IsSectionOffset()) 644 return 0; 645 } 646 } 647 648 if (!prefer_file_cache) 649 { 650 // If we didn't already try and read from the object file cache, then 651 // try it after failing to read from the process. 652 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); 653 } 654 return 0; 655 } 656 657 658 ModuleSP 659 Target::GetSharedModule 660 ( 661 const FileSpec& file_spec, 662 const ArchSpec& arch, 663 const lldb_private::UUID *uuid_ptr, 664 const ConstString *object_name, 665 off_t object_offset, 666 Error *error_ptr 667 ) 668 { 669 // Don't pass in the UUID so we can tell if we have a stale value in our list 670 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library 671 bool did_create_module = false; 672 ModuleSP module_sp; 673 674 Error error; 675 676 // If there are image search path entries, try to use them first to acquire a suitable image. 677 if (m_image_search_paths.GetSize()) 678 { 679 FileSpec transformed_spec; 680 if (m_image_search_paths.RemapPath (file_spec.GetDirectory(), transformed_spec.GetDirectory())) 681 { 682 transformed_spec.GetFilename() = file_spec.GetFilename(); 683 error = ModuleList::GetSharedModule (transformed_spec, arch, uuid_ptr, object_name, object_offset, module_sp, &old_module_sp, &did_create_module); 684 } 685 } 686 687 // The platform is responsible for finding and caching an appropriate 688 // module in the shared module cache. 689 if (m_platform_sp) 690 { 691 FileSpec platform_file_spec; 692 error = m_platform_sp->GetSharedModule (file_spec, 693 arch, 694 uuid_ptr, 695 object_name, 696 object_offset, 697 module_sp, 698 &old_module_sp, 699 &did_create_module); 700 } 701 else 702 { 703 error.SetErrorString("no platform is currently set"); 704 } 705 706 // If a module hasn't been found yet, use the unmodified path. 707 if (module_sp) 708 { 709 m_images.Append (module_sp); 710 if (did_create_module) 711 { 712 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32) 713 ModuleUpdated(old_module_sp, module_sp); 714 else 715 ModuleAdded(module_sp); 716 } 717 } 718 if (error_ptr) 719 *error_ptr = error; 720 return module_sp; 721 } 722 723 724 Target * 725 Target::CalculateTarget () 726 { 727 return this; 728 } 729 730 Process * 731 Target::CalculateProcess () 732 { 733 return NULL; 734 } 735 736 Thread * 737 Target::CalculateThread () 738 { 739 return NULL; 740 } 741 742 StackFrame * 743 Target::CalculateStackFrame () 744 { 745 return NULL; 746 } 747 748 void 749 Target::CalculateExecutionContext (ExecutionContext &exe_ctx) 750 { 751 exe_ctx.target = this; 752 exe_ctx.process = NULL; // Do NOT fill in process... 753 exe_ctx.thread = NULL; 754 exe_ctx.frame = NULL; 755 } 756 757 PathMappingList & 758 Target::GetImageSearchPathList () 759 { 760 return m_image_search_paths; 761 } 762 763 void 764 Target::ImageSearchPathsChanged 765 ( 766 const PathMappingList &path_list, 767 void *baton 768 ) 769 { 770 Target *target = (Target *)baton; 771 if (target->m_images.GetSize() > 1) 772 { 773 ModuleSP exe_module_sp (target->GetExecutableModule()); 774 if (exe_module_sp) 775 { 776 target->m_images.Clear(); 777 target->SetExecutableModule (exe_module_sp, true); 778 } 779 } 780 } 781 782 ClangASTContext * 783 Target::GetScratchClangASTContext() 784 { 785 return m_scratch_ast_context_ap.get(); 786 } 787 788 void 789 Target::SettingsInitialize () 790 { 791 UserSettingsControllerSP &usc = GetSettingsController(); 792 usc.reset (new SettingsController); 793 UserSettingsController::InitializeSettingsController (usc, 794 SettingsController::global_settings_table, 795 SettingsController::instance_settings_table); 796 797 // Now call SettingsInitialize() on each 'child' setting of Target 798 Process::SettingsInitialize (); 799 } 800 801 void 802 Target::SettingsTerminate () 803 { 804 805 // Must call SettingsTerminate() on each settings 'child' of Target, before terminating Target's Settings. 806 807 Process::SettingsTerminate (); 808 809 // Now terminate Target Settings. 810 811 UserSettingsControllerSP &usc = GetSettingsController(); 812 UserSettingsController::FinalizeSettingsController (usc); 813 usc.reset(); 814 } 815 816 UserSettingsControllerSP & 817 Target::GetSettingsController () 818 { 819 static UserSettingsControllerSP g_settings_controller; 820 return g_settings_controller; 821 } 822 823 ArchSpec 824 Target::GetDefaultArchitecture () 825 { 826 lldb::UserSettingsControllerSP settings_controller_sp (GetSettingsController()); 827 828 if (settings_controller_sp) 829 return static_cast<Target::SettingsController *>(settings_controller_sp.get())->GetArchitecture (); 830 return ArchSpec(); 831 } 832 833 void 834 Target::SetDefaultArchitecture (const ArchSpec& arch) 835 { 836 lldb::UserSettingsControllerSP settings_controller_sp (GetSettingsController()); 837 838 if (settings_controller_sp) 839 static_cast<Target::SettingsController *>(settings_controller_sp.get())->GetArchitecture () = arch; 840 } 841 842 Target * 843 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) 844 { 845 // The target can either exist in the "process" of ExecutionContext, or in 846 // the "target_sp" member of SymbolContext. This accessor helper function 847 // will get the target from one of these locations. 848 849 Target *target = NULL; 850 if (sc_ptr != NULL) 851 target = sc_ptr->target_sp.get(); 852 if (target == NULL) 853 { 854 if (exe_ctx_ptr != NULL && exe_ctx_ptr->process != NULL) 855 target = &exe_ctx_ptr->process->GetTarget(); 856 } 857 return target; 858 } 859 860 861 void 862 Target::UpdateInstanceName () 863 { 864 StreamString sstr; 865 866 ModuleSP module_sp = GetExecutableModule(); 867 if (module_sp) 868 { 869 sstr.Printf ("%s_%s", 870 module_sp->GetFileSpec().GetFilename().AsCString(), 871 module_sp->GetArchitecture().GetArchitectureName()); 872 GetSettingsController()->RenameInstanceSettings (GetInstanceName().AsCString(), 873 sstr.GetData()); 874 } 875 } 876 877 const char * 878 Target::GetExpressionPrefixContentsAsCString () 879 { 880 return m_expr_prefix_contents.c_str(); 881 } 882 883 ExecutionResults 884 Target::EvaluateExpression 885 ( 886 const char *expr_cstr, 887 StackFrame *frame, 888 bool unwind_on_error, 889 bool keep_in_memory, 890 lldb::ValueObjectSP &result_valobj_sp 891 ) 892 { 893 ExecutionResults execution_results = eExecutionSetupError; 894 895 result_valobj_sp.reset(); 896 897 ExecutionContext exe_ctx; 898 if (frame) 899 { 900 frame->CalculateExecutionContext(exe_ctx); 901 Error error; 902 const uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember | 903 StackFrame::eExpressionPathOptionsNoFragileObjcIvar; 904 result_valobj_sp = frame->GetValueForVariableExpressionPath (expr_cstr, expr_path_options, error); 905 } 906 else if (m_process_sp) 907 { 908 m_process_sp->CalculateExecutionContext(exe_ctx); 909 } 910 else 911 { 912 CalculateExecutionContext(exe_ctx); 913 } 914 915 if (result_valobj_sp) 916 { 917 execution_results = eExecutionCompleted; 918 // We got a result from the frame variable expression path above... 919 ConstString persistent_variable_name (m_persistent_variables.GetNextPersistentVariableName()); 920 921 lldb::ValueObjectSP const_valobj_sp; 922 923 // Check in case our value is already a constant value 924 if (result_valobj_sp->GetIsConstant()) 925 { 926 const_valobj_sp = result_valobj_sp; 927 const_valobj_sp->SetName (persistent_variable_name); 928 } 929 else 930 const_valobj_sp = result_valobj_sp->CreateConstantValue (persistent_variable_name); 931 932 lldb::ValueObjectSP live_valobj_sp = result_valobj_sp; 933 934 result_valobj_sp = const_valobj_sp; 935 936 ClangExpressionVariableSP clang_expr_variable_sp(m_persistent_variables.CreatePersistentVariable(result_valobj_sp)); 937 assert (clang_expr_variable_sp.get()); 938 939 // Set flags and live data as appropriate 940 941 const Value &result_value = live_valobj_sp->GetValue(); 942 943 switch (result_value.GetValueType()) 944 { 945 case Value::eValueTypeHostAddress: 946 case Value::eValueTypeFileAddress: 947 // we don't do anything with these for now 948 break; 949 case Value::eValueTypeScalar: 950 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated; 951 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation; 952 break; 953 case Value::eValueTypeLoadAddress: 954 clang_expr_variable_sp->m_live_sp = live_valobj_sp; 955 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference; 956 break; 957 } 958 } 959 else 960 { 961 // Make sure we aren't just trying to see the value of a persistent 962 // variable (something like "$0") 963 lldb::ClangExpressionVariableSP persistent_var_sp; 964 // Only check for persistent variables the expression starts with a '$' 965 if (expr_cstr[0] == '$') 966 persistent_var_sp = m_persistent_variables.GetVariable (expr_cstr); 967 968 if (persistent_var_sp) 969 { 970 result_valobj_sp = persistent_var_sp->GetValueObject (); 971 execution_results = eExecutionCompleted; 972 } 973 else 974 { 975 const char *prefix = GetExpressionPrefixContentsAsCString(); 976 977 execution_results = ClangUserExpression::Evaluate (exe_ctx, 978 unwind_on_error, 979 keep_in_memory, 980 expr_cstr, 981 prefix, 982 result_valobj_sp); 983 } 984 } 985 return execution_results; 986 } 987 988 lldb::user_id_t 989 Target::AddStopHook (Target::StopHookSP &new_hook_sp) 990 { 991 lldb::user_id_t new_uid = ++m_stop_hook_next_id; 992 new_hook_sp.reset (new StopHook(GetSP(), new_uid)); 993 m_stop_hooks[new_uid] = new_hook_sp; 994 return new_uid; 995 } 996 997 bool 998 Target::RemoveStopHookByID (lldb::user_id_t user_id) 999 { 1000 size_t num_removed; 1001 num_removed = m_stop_hooks.erase (user_id); 1002 if (num_removed == 0) 1003 return false; 1004 else 1005 return true; 1006 } 1007 1008 void 1009 Target::RemoveAllStopHooks () 1010 { 1011 m_stop_hooks.clear(); 1012 } 1013 1014 Target::StopHookSP 1015 Target::GetStopHookByID (lldb::user_id_t user_id) 1016 { 1017 StopHookSP found_hook; 1018 1019 StopHookCollection::iterator specified_hook_iter; 1020 specified_hook_iter = m_stop_hooks.find (user_id); 1021 if (specified_hook_iter != m_stop_hooks.end()) 1022 found_hook = (*specified_hook_iter).second; 1023 return found_hook; 1024 } 1025 1026 bool 1027 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state) 1028 { 1029 StopHookCollection::iterator specified_hook_iter; 1030 specified_hook_iter = m_stop_hooks.find (user_id); 1031 if (specified_hook_iter == m_stop_hooks.end()) 1032 return false; 1033 1034 (*specified_hook_iter).second->SetIsActive (active_state); 1035 return true; 1036 } 1037 1038 void 1039 Target::SetAllStopHooksActiveState (bool active_state) 1040 { 1041 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 1042 for (pos = m_stop_hooks.begin(); pos != end; pos++) 1043 { 1044 (*pos).second->SetIsActive (active_state); 1045 } 1046 } 1047 1048 void 1049 Target::RunStopHooks () 1050 { 1051 if (!m_process_sp) 1052 return; 1053 1054 if (m_stop_hooks.empty()) 1055 return; 1056 1057 StopHookCollection::iterator pos, end = m_stop_hooks.end(); 1058 1059 // If there aren't any active stop hooks, don't bother either: 1060 bool any_active_hooks = false; 1061 for (pos = m_stop_hooks.begin(); pos != end; pos++) 1062 { 1063 if ((*pos).second->IsActive()) 1064 { 1065 any_active_hooks = true; 1066 break; 1067 } 1068 } 1069 if (!any_active_hooks) 1070 return; 1071 1072 CommandReturnObject result; 1073 1074 std::vector<ExecutionContext> exc_ctx_with_reasons; 1075 std::vector<SymbolContext> sym_ctx_with_reasons; 1076 1077 ThreadList &cur_threadlist = m_process_sp->GetThreadList(); 1078 size_t num_threads = cur_threadlist.GetSize(); 1079 for (size_t i = 0; i < num_threads; i++) 1080 { 1081 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i); 1082 if (cur_thread_sp->ThreadStoppedForAReason()) 1083 { 1084 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0); 1085 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get())); 1086 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything)); 1087 } 1088 } 1089 1090 // If no threads stopped for a reason, don't run the stop-hooks. 1091 size_t num_exe_ctx = exc_ctx_with_reasons.size(); 1092 if (num_exe_ctx == 0) 1093 return; 1094 1095 result.SetImmediateOutputFile (m_debugger.GetOutputFile().GetStream()); 1096 result.SetImmediateErrorFile (m_debugger.GetErrorFile().GetStream()); 1097 1098 bool keep_going = true; 1099 bool hooks_ran = false; 1100 bool print_hook_header; 1101 bool print_thread_header; 1102 1103 if (num_exe_ctx == 1) 1104 print_thread_header = false; 1105 else 1106 print_thread_header = true; 1107 1108 if (m_stop_hooks.size() == 1) 1109 print_hook_header = false; 1110 else 1111 print_hook_header = true; 1112 1113 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) 1114 { 1115 // result.Clear(); 1116 StopHookSP cur_hook_sp = (*pos).second; 1117 if (!cur_hook_sp->IsActive()) 1118 continue; 1119 1120 bool any_thread_matched = false; 1121 for (size_t i = 0; keep_going && i < num_exe_ctx; i++) 1122 { 1123 if ((cur_hook_sp->GetSpecifier () == NULL 1124 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i])) 1125 && (cur_hook_sp->GetThreadSpecifier() == NULL 1126 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].thread))) 1127 { 1128 if (!hooks_ran) 1129 { 1130 result.AppendMessage("\n** Stop Hooks **"); 1131 hooks_ran = true; 1132 } 1133 if (print_hook_header && !any_thread_matched) 1134 { 1135 result.AppendMessageWithFormat("\n- Hook %d\n", cur_hook_sp->GetID()); 1136 any_thread_matched = true; 1137 } 1138 1139 if (print_thread_header) 1140 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].thread->GetIndexID()); 1141 1142 bool stop_on_continue = true; 1143 bool stop_on_error = true; 1144 bool echo_commands = false; 1145 bool print_results = true; 1146 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(), 1147 &exc_ctx_with_reasons[i], 1148 stop_on_continue, 1149 stop_on_error, 1150 echo_commands, 1151 print_results, 1152 result); 1153 1154 // If the command started the target going again, we should bag out of 1155 // running the stop hooks. 1156 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) || 1157 (result.GetStatus() == eReturnStatusSuccessContinuingResult)) 1158 { 1159 result.AppendMessageWithFormat ("Aborting stop hooks, hook %d set the program running.", cur_hook_sp->GetID()); 1160 keep_going = false; 1161 } 1162 } 1163 } 1164 } 1165 if (hooks_ran) 1166 result.AppendMessage ("\n** End Stop Hooks **\n"); 1167 } 1168 1169 //-------------------------------------------------------------- 1170 // class Target::StopHook 1171 //-------------------------------------------------------------- 1172 1173 1174 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : 1175 UserID (uid), 1176 m_target_sp (target_sp), 1177 m_commands (), 1178 m_specifier_sp (), 1179 m_thread_spec_ap(NULL), 1180 m_active (true) 1181 { 1182 } 1183 1184 Target::StopHook::StopHook (const StopHook &rhs) : 1185 UserID (rhs.GetID()), 1186 m_target_sp (rhs.m_target_sp), 1187 m_commands (rhs.m_commands), 1188 m_specifier_sp (rhs.m_specifier_sp), 1189 m_thread_spec_ap (NULL), 1190 m_active (rhs.m_active) 1191 { 1192 if (rhs.m_thread_spec_ap.get() != NULL) 1193 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); 1194 } 1195 1196 1197 Target::StopHook::~StopHook () 1198 { 1199 } 1200 1201 void 1202 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) 1203 { 1204 m_thread_spec_ap.reset (specifier); 1205 } 1206 1207 1208 void 1209 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const 1210 { 1211 int indent_level = s->GetIndentLevel(); 1212 1213 s->SetIndentLevel(indent_level + 2); 1214 1215 s->Printf ("Hook: %d\n", GetID()); 1216 if (m_active) 1217 s->Indent ("State: enabled\n"); 1218 else 1219 s->Indent ("State: disabled\n"); 1220 1221 if (m_specifier_sp) 1222 { 1223 s->Indent(); 1224 s->PutCString ("Specifier:\n"); 1225 s->SetIndentLevel (indent_level + 4); 1226 m_specifier_sp->GetDescription (s, level); 1227 s->SetIndentLevel (indent_level + 2); 1228 } 1229 1230 if (m_thread_spec_ap.get() != NULL) 1231 { 1232 StreamString tmp; 1233 s->Indent("Thread:\n"); 1234 m_thread_spec_ap->GetDescription (&tmp, level); 1235 s->SetIndentLevel (indent_level + 4); 1236 s->Indent (tmp.GetData()); 1237 s->PutCString ("\n"); 1238 s->SetIndentLevel (indent_level + 2); 1239 } 1240 1241 s->Indent ("Commands: \n"); 1242 s->SetIndentLevel (indent_level + 4); 1243 uint32_t num_commands = m_commands.GetSize(); 1244 for (uint32_t i = 0; i < num_commands; i++) 1245 { 1246 s->Indent(m_commands.GetStringAtIndex(i)); 1247 s->PutCString ("\n"); 1248 } 1249 s->SetIndentLevel (indent_level); 1250 } 1251 1252 1253 //-------------------------------------------------------------- 1254 // class Target::SettingsController 1255 //-------------------------------------------------------------- 1256 1257 Target::SettingsController::SettingsController () : 1258 UserSettingsController ("target", Debugger::GetSettingsController()), 1259 m_default_architecture () 1260 { 1261 m_default_settings.reset (new TargetInstanceSettings (*this, false, 1262 InstanceSettings::GetDefaultName().AsCString())); 1263 } 1264 1265 Target::SettingsController::~SettingsController () 1266 { 1267 } 1268 1269 lldb::InstanceSettingsSP 1270 Target::SettingsController::CreateInstanceSettings (const char *instance_name) 1271 { 1272 TargetInstanceSettings *new_settings = new TargetInstanceSettings (*GetSettingsController(), 1273 false, 1274 instance_name); 1275 lldb::InstanceSettingsSP new_settings_sp (new_settings); 1276 return new_settings_sp; 1277 } 1278 1279 1280 #define TSC_DEFAULT_ARCH "default-arch" 1281 #define TSC_EXPR_PREFIX "expr-prefix" 1282 #define TSC_EXEC_LEVEL "execution-level" 1283 #define TSC_EXEC_MODE "execution-mode" 1284 #define TSC_EXEC_OS_TYPE "execution-os-type" 1285 1286 1287 static const ConstString & 1288 GetSettingNameForDefaultArch () 1289 { 1290 static ConstString g_const_string (TSC_DEFAULT_ARCH); 1291 1292 return g_const_string; 1293 } 1294 1295 static const ConstString & 1296 GetSettingNameForExpressionPrefix () 1297 { 1298 static ConstString g_const_string (TSC_EXPR_PREFIX); 1299 return g_const_string; 1300 } 1301 1302 static const ConstString & 1303 GetSettingNameForExecutionLevel () 1304 { 1305 static ConstString g_const_string (TSC_EXEC_LEVEL); 1306 return g_const_string; 1307 } 1308 1309 static const ConstString & 1310 GetSettingNameForExecutionMode () 1311 { 1312 static ConstString g_const_string (TSC_EXEC_MODE); 1313 return g_const_string; 1314 } 1315 1316 static const ConstString & 1317 GetSettingNameForExecutionOSType () 1318 { 1319 static ConstString g_const_string (TSC_EXEC_OS_TYPE); 1320 return g_const_string; 1321 } 1322 1323 1324 bool 1325 Target::SettingsController::SetGlobalVariable (const ConstString &var_name, 1326 const char *index_value, 1327 const char *value, 1328 const SettingEntry &entry, 1329 const VarSetOperationType op, 1330 Error&err) 1331 { 1332 if (var_name == GetSettingNameForDefaultArch()) 1333 { 1334 m_default_architecture.SetTriple (value, NULL); 1335 if (!m_default_architecture.IsValid()) 1336 err.SetErrorStringWithFormat ("'%s' is not a valid architecture or triple.", value); 1337 } 1338 return true; 1339 } 1340 1341 1342 bool 1343 Target::SettingsController::GetGlobalVariable (const ConstString &var_name, 1344 StringList &value, 1345 Error &err) 1346 { 1347 if (var_name == GetSettingNameForDefaultArch()) 1348 { 1349 // If the arch is invalid (the default), don't show a string for it 1350 if (m_default_architecture.IsValid()) 1351 value.AppendString (m_default_architecture.GetArchitectureName()); 1352 return true; 1353 } 1354 else 1355 err.SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); 1356 1357 return false; 1358 } 1359 1360 //-------------------------------------------------------------- 1361 // class TargetInstanceSettings 1362 //-------------------------------------------------------------- 1363 1364 TargetInstanceSettings::TargetInstanceSettings 1365 ( 1366 UserSettingsController &owner, 1367 bool live_instance, 1368 const char *name 1369 ) : 1370 InstanceSettings (owner, name ? name : InstanceSettings::InvalidName().AsCString(), live_instance), 1371 m_expr_prefix_path (), 1372 m_expr_prefix_contents () 1373 { 1374 // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called 1375 // until the vtables for TargetInstanceSettings are properly set up, i.e. AFTER all the initializers. 1376 // For this reason it has to be called here, rather than in the initializer or in the parent constructor. 1377 // This is true for CreateInstanceName() too. 1378 1379 if (GetInstanceName () == InstanceSettings::InvalidName()) 1380 { 1381 ChangeInstanceName (std::string (CreateInstanceName().AsCString())); 1382 m_owner.RegisterInstanceSettings (this); 1383 } 1384 1385 if (live_instance) 1386 { 1387 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); 1388 CopyInstanceSettings (pending_settings,false); 1389 //m_owner.RemovePendingSettings (m_instance_name); 1390 } 1391 } 1392 1393 TargetInstanceSettings::TargetInstanceSettings (const TargetInstanceSettings &rhs) : 1394 InstanceSettings (*Target::GetSettingsController(), CreateInstanceName().AsCString()) 1395 { 1396 if (m_instance_name != InstanceSettings::GetDefaultName()) 1397 { 1398 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); 1399 CopyInstanceSettings (pending_settings,false); 1400 //m_owner.RemovePendingSettings (m_instance_name); 1401 } 1402 } 1403 1404 TargetInstanceSettings::~TargetInstanceSettings () 1405 { 1406 } 1407 1408 TargetInstanceSettings& 1409 TargetInstanceSettings::operator= (const TargetInstanceSettings &rhs) 1410 { 1411 if (this != &rhs) 1412 { 1413 } 1414 1415 return *this; 1416 } 1417 1418 void 1419 TargetInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name, 1420 const char *index_value, 1421 const char *value, 1422 const ConstString &instance_name, 1423 const SettingEntry &entry, 1424 VarSetOperationType op, 1425 Error &err, 1426 bool pending) 1427 { 1428 if (var_name == GetSettingNameForExpressionPrefix ()) 1429 { 1430 switch (op) 1431 { 1432 default: 1433 err.SetErrorToGenericError (); 1434 err.SetErrorString ("Unrecognized operation. Cannot update value.\n"); 1435 return; 1436 case eVarSetOperationAssign: 1437 { 1438 FileSpec file_spec(value, true); 1439 1440 if (!file_spec.Exists()) 1441 { 1442 err.SetErrorToGenericError (); 1443 err.SetErrorStringWithFormat ("%s does not exist.\n", value); 1444 return; 1445 } 1446 1447 DataBufferSP data_sp (file_spec.ReadFileContents()); 1448 1449 if (!data_sp && data_sp->GetByteSize() == 0) 1450 { 1451 err.SetErrorToGenericError (); 1452 err.SetErrorStringWithFormat ("Couldn't read from %s\n", value); 1453 return; 1454 } 1455 1456 m_expr_prefix_path = value; 1457 m_expr_prefix_contents.assign(reinterpret_cast<const char *>(data_sp->GetBytes()), data_sp->GetByteSize()); 1458 } 1459 return; 1460 case eVarSetOperationAppend: 1461 err.SetErrorToGenericError (); 1462 err.SetErrorString ("Cannot append to a path.\n"); 1463 return; 1464 case eVarSetOperationClear: 1465 m_expr_prefix_path.clear (); 1466 m_expr_prefix_contents.clear (); 1467 return; 1468 } 1469 } 1470 } 1471 1472 void 1473 TargetInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings, bool pending) 1474 { 1475 TargetInstanceSettings *new_settings_ptr = static_cast <TargetInstanceSettings *> (new_settings.get()); 1476 1477 if (!new_settings_ptr) 1478 return; 1479 1480 m_expr_prefix_path = new_settings_ptr->m_expr_prefix_path; 1481 m_expr_prefix_contents = new_settings_ptr->m_expr_prefix_contents; 1482 } 1483 1484 bool 1485 TargetInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry, 1486 const ConstString &var_name, 1487 StringList &value, 1488 Error *err) 1489 { 1490 if (var_name == GetSettingNameForExpressionPrefix ()) 1491 { 1492 value.AppendString (m_expr_prefix_path.c_str(), m_expr_prefix_path.size()); 1493 } 1494 else 1495 { 1496 if (err) 1497 err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); 1498 return false; 1499 } 1500 1501 return true; 1502 } 1503 1504 const ConstString 1505 TargetInstanceSettings::CreateInstanceName () 1506 { 1507 StreamString sstr; 1508 static int instance_count = 1; 1509 1510 sstr.Printf ("target_%d", instance_count); 1511 ++instance_count; 1512 1513 const ConstString ret_val (sstr.GetData()); 1514 return ret_val; 1515 } 1516 1517 //-------------------------------------------------- 1518 // Target::SettingsController Variable Tables 1519 //-------------------------------------------------- 1520 1521 SettingEntry 1522 Target::SettingsController::global_settings_table[] = 1523 { 1524 // var-name var-type default enum init'd hidden help-text 1525 // ================= ================== =========== ==== ====== ====== ========================================================================= 1526 { TSC_DEFAULT_ARCH , eSetVarTypeString , NULL , NULL, false, false, "Default architecture to choose, when there's a choice." }, 1527 { NULL , eSetVarTypeNone , NULL , NULL, false, false, NULL } 1528 }; 1529 1530 SettingEntry 1531 Target::SettingsController::instance_settings_table[] = 1532 { 1533 // var-name var-type default enum init'd hidden help-text 1534 // ================= ================== =========== ==== ====== ====== ========================================================================= 1535 { TSC_EXPR_PREFIX , eSetVarTypeString , NULL , NULL, false, false, "Path to a file containing expressions to be prepended to all expressions." }, 1536 { NULL , eSetVarTypeNone , NULL , NULL, false, false, NULL } 1537 }; 1538