contrib/llvm/tools/lldb/source/Target/Target.cpp

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