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