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 // C Includes
  11 // C++ Includes
  12 // Other libraries and framework includes
  13 // Project includes
  14 #include "lldb/Target/Target.h"
  15 #include "lldb/Breakpoint/BreakpointResolver.h"
  16 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
  17 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
  18 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
  19 #include "lldb/Breakpoint/BreakpointResolverName.h"
  20 #include "lldb/Breakpoint/Watchpoint.h"
  21 #include "lldb/Core/Debugger.h"
  22 #include "lldb/Core/Event.h"
  23 #include "lldb/Core/Log.h"
  24 #include "lldb/Core/Module.h"
  25 #include "lldb/Core/ModuleSpec.h"
  26 #include "lldb/Core/Section.h"
  27 #include "lldb/Core/SourceManager.h"
  28 #include "lldb/Core/State.h"
  29 #include "lldb/Core/StreamFile.h"
  30 #include "lldb/Core/StreamString.h"
  31 #include "lldb/Core/Timer.h"
  32 #include "lldb/Core/ValueObject.h"
  33 #include "lldb/Expression/REPL.h"
  34 #include "lldb/Expression/UserExpression.h"
  35 #include "Plugins/ExpressionParser/Clang/ClangASTSource.h"
  36 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
  37 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
  38 #include "lldb/Host/FileSpec.h"
  39 #include "lldb/Host/Host.h"
  40 #include "lldb/Interpreter/CommandInterpreter.h"
  41 #include "lldb/Interpreter/CommandReturnObject.h"
  42 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
  43 #include "lldb/Interpreter/OptionValues.h"
  44 #include "lldb/Interpreter/Property.h"
  45 #include "lldb/Symbol/ClangASTContext.h"
  46 #include "lldb/Symbol/ObjectFile.h"
  47 #include "lldb/Symbol/Function.h"
  48 #include "lldb/Symbol/Symbol.h"
  49 #include "lldb/Target/Language.h"
  50 #include "lldb/Target/LanguageRuntime.h"
  51 #include "lldb/Target/ObjCLanguageRuntime.h"
  52 #include "lldb/Target/Process.h"
  53 #include "lldb/Target/SectionLoadList.h"
  54 #include "lldb/Target/StackFrame.h"
  55 #include "lldb/Target/SystemRuntime.h"
  56 #include "lldb/Target/Thread.h"
  57 #include "lldb/Target/ThreadSpec.h"
  58 #include "lldb/Utility/LLDBAssert.h"
  59
  60 using namespace lldb;
  61 using namespace lldb_private;
  62
  63 ConstString &
  64 Target::GetStaticBroadcasterClass ()
  65 {
  66     static ConstString class_name ("lldb.target");
  67     return class_name;
  68 }
  69
  70 Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target) :
  71     TargetProperties (this),
  72     Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()),
  73     ExecutionContextScope (),
  74     m_debugger (debugger),
  75     m_platform_sp (platform_sp),
  76     m_mutex (Mutex::eMutexTypeRecursive),
  77     m_arch (target_arch),
  78     m_images (this),
  79     m_section_load_history (),
  80     m_breakpoint_list (false),
  81     m_internal_breakpoint_list (true),
  82     m_watchpoint_list (),
  83     m_process_sp (),
  84     m_search_filter_sp (),
  85     m_image_search_paths (ImageSearchPathsChanged, this),
  86     m_ast_importer_sp (),
  87     m_source_manager_ap(),
  88     m_stop_hooks (),
  89     m_stop_hook_next_id (0),
  90     m_valid (true),
  91     m_suppress_stop_hooks (false),
  92     m_is_dummy_target(is_dummy_target)
  93
  94 {
  95     SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed");
  96     SetEventName (eBroadcastBitModulesLoaded, "modules-loaded");
  97     SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded");
  98     SetEventName (eBroadcastBitWatchpointChanged, "watchpoint-changed");
  99     SetEventName (eBroadcastBitSymbolsLoaded, "symbols-loaded");
 100
 101     CheckInWithManager();
 102
 103     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
 104     if (log)
 105         log->Printf ("%p Target::Target()", static_cast<void*>(this));
 106     if (m_arch.IsValid())
 107     {
 108         LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
 109     }
 110 }
 111
 112 Target::~Target()
 113 {
 114     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
 115     if (log)
 116         log->Printf ("%p Target::~Target()", static_cast<void*>(this));
 117     DeleteCurrentProcess ();
 118 }
 119
 120 void
 121 Target::PrimeFromDummyTarget(Target *target)
 122 {
 123     if (!target)
 124         return;
 125
 126     m_stop_hooks = target->m_stop_hooks;
 127
 128     for (BreakpointSP breakpoint_sp : target->m_breakpoint_list.Breakpoints())
 129     {
 130         if (breakpoint_sp->IsInternal())
 131             continue;
 132
 133         BreakpointSP new_bp (new Breakpoint (*this, *breakpoint_sp.get()));
 134         AddBreakpoint (new_bp, false);
 135     }
 136 }
 137
 138 void
 139 Target::Dump (Stream *s, lldb::DescriptionLevel description_level)
 140 {
 141 //    s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
 142     if (description_level != lldb::eDescriptionLevelBrief)
 143     {
 144         s->Indent();
 145         s->PutCString("Target\n");
 146         s->IndentMore();
 147             m_images.Dump(s);
 148             m_breakpoint_list.Dump(s);
 149             m_internal_breakpoint_list.Dump(s);
 150         s->IndentLess();
 151     }
 152     else
 153     {
 154         Module *exe_module = GetExecutableModulePointer();
 155         if (exe_module)
 156             s->PutCString (exe_module->GetFileSpec().GetFilename().GetCString());
 157         else
 158             s->PutCString ("No executable module.");
 159     }
 160 }
 161
 162 void
 163 Target::CleanupProcess ()
 164 {
 165     // Do any cleanup of the target we need to do between process instances.
 166     // NB It is better to do this before destroying the process in case the
 167     // clean up needs some help from the process.
 168     m_breakpoint_list.ClearAllBreakpointSites();
 169     m_internal_breakpoint_list.ClearAllBreakpointSites();
 170     // Disable watchpoints just on the debugger side.
 171     Mutex::Locker locker;
 172     this->GetWatchpointList().GetListMutex(locker);
 173     DisableAllWatchpoints(false);
 174     ClearAllWatchpointHitCounts();
 175     ClearAllWatchpointHistoricValues();
 176 }
 177
 178 void
 179 Target::DeleteCurrentProcess ()
 180 {
 181     if (m_process_sp)
 182     {
 183         m_section_load_history.Clear();
 184         if (m_process_sp->IsAlive())
 185             m_process_sp->Destroy(false);
 186
 187         m_process_sp->Finalize();
 188
 189         CleanupProcess ();
 190
 191         m_process_sp.reset();
 192     }
 193 }
 194
 195 const lldb::ProcessSP &
 196 Target::CreateProcess (Listener &listener, const char *plugin_name, const FileSpec *crash_file)
 197 {
 198     DeleteCurrentProcess ();
 199     m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name, listener, crash_file);
 200     return m_process_sp;
 201 }
 202
 203 const lldb::ProcessSP &
 204 Target::GetProcessSP () const
 205 {
 206     return m_process_sp;
 207 }
 208
 209 lldb::REPLSP
 210 Target::GetREPL (Error &err, lldb::LanguageType language, const char *repl_options, bool can_create)
 211 {
 212     if (language == eLanguageTypeUnknown)
 213     {
 214         std::set<LanguageType> repl_languages;
 215
 216         Language::GetLanguagesSupportingREPLs(repl_languages);
 217
 218         if (repl_languages.size() == 1)
 219         {
 220             language = *repl_languages.begin();
 221         }
 222         else if (repl_languages.size() == 0)
 223         {
 224             err.SetErrorStringWithFormat("LLDB isn't configured with support support for any REPLs.");
 225             return REPLSP();
 226         }
 227         else
 228         {
 229             err.SetErrorStringWithFormat("Multiple possible REPL languages.  Please specify a language.");
 230             return REPLSP();
 231         }
 232     }
 233
 234     REPLMap::iterator pos = m_repl_map.find(language);
 235
 236     if (pos != m_repl_map.end())
 237     {
 238         return pos->second;
 239     }
 240
 241     if (!can_create)
 242     {
 243         err.SetErrorStringWithFormat("Couldn't find an existing REPL for %s, and can't create a new one", Language::GetNameForLanguageType(language));
 244         return lldb::REPLSP();
 245     }
 246
 247     Debugger *const debugger = nullptr;
 248     lldb::REPLSP ret = REPL::Create(err, language, debugger, this, repl_options);
 249
 250     if (ret)
 251     {
 252         m_repl_map[language] = ret;
 253         return m_repl_map[language];
 254     }
 255
 256     if (err.Success())
 257     {
 258         err.SetErrorStringWithFormat("Couldn't create a REPL for %s", Language::GetNameForLanguageType(language));
 259     }
 260
 261     return lldb::REPLSP();
 262 }
 263
 264 void
 265 Target::SetREPL (lldb::LanguageType language, lldb::REPLSP repl_sp)
 266 {
 267     lldbassert(!m_repl_map.count(language));
 268
 269     m_repl_map[language] = repl_sp;
 270 }
 271
 272 void
 273 Target::Destroy()
 274 {
 275     Mutex::Locker locker (m_mutex);
 276     m_valid = false;
 277     DeleteCurrentProcess ();
 278     m_platform_sp.reset();
 279     m_arch.Clear();
 280     ClearModules(true);
 281     m_section_load_history.Clear();
 282     const bool notify = false;
 283     m_breakpoint_list.RemoveAll(notify);
 284     m_internal_breakpoint_list.RemoveAll(notify);
 285     m_last_created_breakpoint.reset();
 286     m_last_created_watchpoint.reset();
 287     m_search_filter_sp.reset();
 288     m_image_search_paths.Clear(notify);
 289     m_stop_hooks.clear();
 290     m_stop_hook_next_id = 0;
 291     m_suppress_stop_hooks = false;
 292 }
 293
 294 BreakpointList &
 295 Target::GetBreakpointList(bool internal)
 296 {
 297     if (internal)
 298         return m_internal_breakpoint_list;
 299     else
 300         return m_breakpoint_list;
 301 }
 302
 303 const BreakpointList &
 304 Target::GetBreakpointList(bool internal) const
 305 {
 306     if (internal)
 307         return m_internal_breakpoint_list;
 308     else
 309         return m_breakpoint_list;
 310 }
 311
 312 BreakpointSP
 313 Target::GetBreakpointByID (break_id_t break_id)
 314 {
 315     BreakpointSP bp_sp;
 316
 317     if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
 318         bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
 319     else
 320         bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
 321
 322     return bp_sp;
 323 }
 324
 325 BreakpointSP
 326 Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
 327                                      const FileSpecList *source_file_spec_list,
 328                                      RegularExpression &source_regex,
 329                                      bool internal,
 330                                      bool hardware,
 331                                      LazyBool move_to_nearest_code)
 332 {
 333     SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list));
 334     if (move_to_nearest_code == eLazyBoolCalculate)
 335         move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
 336     BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex(nullptr, source_regex, !static_cast<bool>(move_to_nearest_code)));
 337     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 338 }
 339
 340 BreakpointSP
 341 Target::CreateBreakpoint (const FileSpecList *containingModules,
 342                           const FileSpec &file,
 343                           uint32_t line_no,
 344                           LazyBool check_inlines,
 345                           LazyBool skip_prologue,
 346                           bool internal,
 347                           bool hardware,
 348                           LazyBool move_to_nearest_code)
 349 {
 350     if (check_inlines == eLazyBoolCalculate)
 351     {
 352         const InlineStrategy inline_strategy = GetInlineStrategy();
 353         switch (inline_strategy)
 354         {
 355             case eInlineBreakpointsNever:
 356                 check_inlines = eLazyBoolNo;
 357                 break;
 358
 359             case eInlineBreakpointsHeaders:
 360                 if (file.IsSourceImplementationFile())
 361                     check_inlines = eLazyBoolNo;
 362                 else
 363                     check_inlines = eLazyBoolYes;
 364                 break;
 365
 366             case eInlineBreakpointsAlways:
 367                 check_inlines = eLazyBoolYes;
 368                 break;
 369         }
 370     }
 371     SearchFilterSP filter_sp;
 372     if (check_inlines == eLazyBoolNo)
 373     {
 374         // Not checking for inlines, we are looking only for matching compile units
 375         FileSpecList compile_unit_list;
 376         compile_unit_list.Append (file);
 377         filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list);
 378     }
 379     else
 380     {
 381         filter_sp = GetSearchFilterForModuleList (containingModules);
 382     }
 383     if (skip_prologue == eLazyBoolCalculate)
 384         skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
 385     if (move_to_nearest_code == eLazyBoolCalculate)
 386         move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
 387
 388     BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine(nullptr,
 389                                                                     file,
 390                                                                     line_no,
 391                                                                     check_inlines,
 392                                                                     skip_prologue,
 393                                                                     !static_cast<bool>(move_to_nearest_code)));
 394     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 395 }
 396
 397 BreakpointSP
 398 Target::CreateBreakpoint (lldb::addr_t addr, bool internal, bool hardware)
 399 {
 400     Address so_addr;
 401
 402     // Check for any reason we want to move this breakpoint to other address.
 403     addr = GetBreakableLoadAddress(addr);
 404
 405     // Attempt to resolve our load address if possible, though it is ok if
 406     // it doesn't resolve to section/offset.
 407
 408     // Try and resolve as a load address if possible
 409     GetSectionLoadList().ResolveLoadAddress(addr, so_addr);
 410     if (!so_addr.IsValid())
 411     {
 412         // The address didn't resolve, so just set this as an absolute address
 413         so_addr.SetOffset (addr);
 414     }
 415     BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal, hardware));
 416     return bp_sp;
 417 }
 418
 419 BreakpointSP
 420 Target::CreateBreakpoint (const Address &addr, bool internal, bool hardware)
 421 {
 422     SearchFilterSP filter_sp(new SearchFilterForUnconstrainedSearches (shared_from_this()));
 423     BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(nullptr, addr));
 424     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, false);
 425 }
 426
 427 lldb::BreakpointSP
 428 Target::CreateAddressInModuleBreakpoint (lldb::addr_t file_addr,
 429                                          bool internal,
 430                                          const FileSpec *file_spec,
 431                                          bool request_hardware)
 432 {
 433     SearchFilterSP filter_sp(new SearchFilterForUnconstrainedSearches (shared_from_this()));
 434     BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(nullptr, file_addr, file_spec));
 435     return CreateBreakpoint (filter_sp, resolver_sp, internal, request_hardware, false);
 436 }
 437
 438 BreakpointSP
 439 Target::CreateBreakpoint (const FileSpecList *containingModules,
 440                           const FileSpecList *containingSourceFiles,
 441                           const char *func_name,
 442                           uint32_t func_name_type_mask,
 443                           LanguageType language,
 444                           LazyBool skip_prologue,
 445                           bool internal,
 446                           bool hardware)
 447 {
 448     BreakpointSP bp_sp;
 449     if (func_name)
 450     {
 451         SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
 452
 453         if (skip_prologue == eLazyBoolCalculate)
 454             skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
 455         if (language == lldb::eLanguageTypeUnknown)
 456             language = GetLanguage();
 457
 458         BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
 459                                                                     func_name,
 460                                                                     func_name_type_mask,
 461                                                                     language,
 462                                                                     Breakpoint::Exact,
 463                                                                     skip_prologue));
 464         bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 465     }
 466     return bp_sp;
 467 }
 468
 469 lldb::BreakpointSP
 470 Target::CreateBreakpoint (const FileSpecList *containingModules,
 471                           const FileSpecList *containingSourceFiles,
 472                           const std::vector<std::string> &func_names,
 473                           uint32_t func_name_type_mask,
 474                           LanguageType language,
 475                           LazyBool skip_prologue,
 476                           bool internal,
 477                           bool hardware)
 478 {
 479     BreakpointSP bp_sp;
 480     size_t num_names = func_names.size();
 481     if (num_names > 0)
 482     {
 483         SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
 484
 485         if (skip_prologue == eLazyBoolCalculate)
 486             skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
 487         if (language == lldb::eLanguageTypeUnknown)
 488             language = GetLanguage();
 489
 490         BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
 491                                                                     func_names,
 492                                                                     func_name_type_mask,
 493                                                                     language,
 494                                                                     skip_prologue));
 495         bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 496     }
 497     return bp_sp;
 498 }
 499
 500 BreakpointSP
 501 Target::CreateBreakpoint (const FileSpecList *containingModules,
 502                           const FileSpecList *containingSourceFiles,
 503                           const char *func_names[],
 504                           size_t num_names,
 505                           uint32_t func_name_type_mask,
 506                           LanguageType language,
 507                           LazyBool skip_prologue,
 508                           bool internal,
 509                           bool hardware)
 510 {
 511     BreakpointSP bp_sp;
 512     if (num_names > 0)
 513     {
 514         SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
 515
 516         if (skip_prologue == eLazyBoolCalculate)
 517             skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
 518         if (language == lldb::eLanguageTypeUnknown)
 519             language = GetLanguage();
 520
 521         BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
 522                                                                     func_names,
 523                                                                     num_names,
 524                                                                     func_name_type_mask,
 525                                                                     language,
 526                                                                     skip_prologue));
 527         bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 528     }
 529     return bp_sp;
 530 }
 531
 532 SearchFilterSP
 533 Target::GetSearchFilterForModule (const FileSpec *containingModule)
 534 {
 535     SearchFilterSP filter_sp;
 536     if (containingModule != nullptr)
 537     {
 538         // TODO: We should look into sharing module based search filters
 539         // across many breakpoints like we do for the simple target based one
 540         filter_sp.reset (new SearchFilterByModule (shared_from_this(), *containingModule));
 541     }
 542     else
 543     {
 544         if (!m_search_filter_sp)
 545             m_search_filter_sp.reset (new SearchFilterForUnconstrainedSearches (shared_from_this()));
 546         filter_sp = m_search_filter_sp;
 547     }
 548     return filter_sp;
 549 }
 550
 551 SearchFilterSP
 552 Target::GetSearchFilterForModuleList (const FileSpecList *containingModules)
 553 {
 554     SearchFilterSP filter_sp;
 555     if (containingModules && containingModules->GetSize() != 0)
 556     {
 557         // TODO: We should look into sharing module based search filters
 558         // across many breakpoints like we do for the simple target based one
 559         filter_sp.reset (new SearchFilterByModuleList (shared_from_this(), *containingModules));
 560     }
 561     else
 562     {
 563         if (!m_search_filter_sp)
 564             m_search_filter_sp.reset (new SearchFilterForUnconstrainedSearches (shared_from_this()));
 565         filter_sp = m_search_filter_sp;
 566     }
 567     return filter_sp;
 568 }
 569
 570 SearchFilterSP
 571 Target::GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules,
 572                                            const FileSpecList *containingSourceFiles)
 573 {
 574     if (containingSourceFiles == nullptr || containingSourceFiles->GetSize() == 0)
 575         return GetSearchFilterForModuleList(containingModules);
 576
 577     SearchFilterSP filter_sp;
 578     if (containingModules == nullptr)
 579     {
 580         // We could make a special "CU List only SearchFilter".  Better yet was if these could be composable,
 581         // but that will take a little reworking.
 582
 583         filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), FileSpecList(), *containingSourceFiles));
 584     }
 585     else
 586     {
 587         filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), *containingModules, *containingSourceFiles));
 588     }
 589     return filter_sp;
 590 }
 591
 592 BreakpointSP
 593 Target::CreateFuncRegexBreakpoint (const FileSpecList *containingModules,
 594                                    const FileSpecList *containingSourceFiles,
 595                                    RegularExpression &func_regex,
 596                                    lldb::LanguageType requested_language,
 597                                    LazyBool skip_prologue,
 598                                    bool internal,
 599                                    bool hardware)
 600 {
 601     SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
 602     bool skip =
 603       (skip_prologue == eLazyBoolCalculate) ? GetSkipPrologue()
 604                                             : static_cast<bool>(skip_prologue);
 605     BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
 606                                                                 func_regex,
 607                                                                 requested_language,
 608                                                                 skip));
 609
 610     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 611 }
 612
 613 lldb::BreakpointSP
 614 Target::CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args, Error *error)
 615 {
 616     BreakpointSP exc_bkpt_sp = LanguageRuntime::CreateExceptionBreakpoint (*this, language, catch_bp, throw_bp, internal);
 617     if (exc_bkpt_sp && additional_args)
 618     {
 619         Breakpoint::BreakpointPreconditionSP precondition_sp = exc_bkpt_sp->GetPrecondition();
 620         if (precondition_sp && additional_args)
 621         {
 622             if (error)
 623                 *error = precondition_sp->ConfigurePrecondition(*additional_args);
 624             else
 625                 precondition_sp->ConfigurePrecondition(*additional_args);
 626         }
 627     }
 628     return exc_bkpt_sp;
 629 }
 630
 631 BreakpointSP
 632 Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal, bool request_hardware, bool resolve_indirect_symbols)
 633 {
 634     BreakpointSP bp_sp;
 635     if (filter_sp && resolver_sp)
 636     {
 637         bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp, request_hardware, resolve_indirect_symbols));
 638         resolver_sp->SetBreakpoint (bp_sp.get());
 639         AddBreakpoint (bp_sp, internal);
 640     }
 641     return bp_sp;
 642 }
 643
 644 void
 645 Target::AddBreakpoint (lldb::BreakpointSP bp_sp, bool internal)
 646 {
 647     if (!bp_sp)
 648         return;
 649     if (internal)
 650         m_internal_breakpoint_list.Add (bp_sp, false);
 651     else
 652         m_breakpoint_list.Add (bp_sp, true);
 653
 654     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 655     if (log)
 656     {
 657         StreamString s;
 658         bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
 659         log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, bp_sp->IsInternal() ? "yes" : "no", s.GetData());
 660     }
 661
 662     bp_sp->ResolveBreakpoint();
 663
 664     if (!internal)
 665     {
 666         m_last_created_breakpoint = bp_sp;
 667     }
 668 }
 669
 670 bool
 671 Target::ProcessIsValid()
 672 {
 673     return (m_process_sp && m_process_sp->IsAlive());
 674 }
 675
 676 static bool
 677 CheckIfWatchpointsExhausted(Target *target, Error &error)
 678 {
 679     uint32_t num_supported_hardware_watchpoints;
 680     Error rc = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints);
 681     if (rc.Success())
 682     {
 683         uint32_t num_current_watchpoints = target->GetWatchpointList().GetSize();
 684         if (num_current_watchpoints >= num_supported_hardware_watchpoints)
 685             error.SetErrorStringWithFormat("number of supported hardware watchpoints (%u) has been reached",
 686                                            num_supported_hardware_watchpoints);
 687     }
 688     return false;
 689 }
 690
 691 // See also Watchpoint::SetWatchpointType(uint32_t type) and
 692 // the OptionGroupWatchpoint::WatchType enum type.
 693 WatchpointSP
 694 Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Error &error)
 695 {
 696     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
 697     if (log)
 698         log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64 " type = %u)\n",
 699                     __FUNCTION__, addr, (uint64_t)size, kind);
 700
 701     WatchpointSP wp_sp;
 702     if (!ProcessIsValid())
 703     {
 704         error.SetErrorString("process is not alive");
 705         return wp_sp;
 706     }
 707
 708     if (addr == LLDB_INVALID_ADDRESS || size == 0)
 709     {
 710         if (size == 0)
 711             error.SetErrorString("cannot set a watchpoint with watch_size of 0");
 712         else
 713             error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr);
 714         return wp_sp;
 715     }
 716
 717     if (!LLDB_WATCH_TYPE_IS_VALID(kind))
 718     {
 719         error.SetErrorStringWithFormat ("invalid watchpoint type: %d", kind);
 720     }
 721
 722     // Currently we only support one watchpoint per address, with total number
 723     // of watchpoints limited by the hardware which the inferior is running on.
 724
 725     // Grab the list mutex while doing operations.
 726     const bool notify = false;   // Don't notify about all the state changes we do on creating the watchpoint.
 727     Mutex::Locker locker;
 728     this->GetWatchpointList().GetListMutex(locker);
 729     WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr);
 730     if (matched_sp)
 731     {
 732         size_t old_size = matched_sp->GetByteSize();
 733         uint32_t old_type =
 734             (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) |
 735             (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0);
 736         // Return the existing watchpoint if both size and type match.
 737         if (size == old_size && kind == old_type)
 738         {
 739             wp_sp = matched_sp;
 740             wp_sp->SetEnabled(false, notify);
 741         }
 742         else
 743         {
 744             // Nil the matched watchpoint; we will be creating a new one.
 745             m_process_sp->DisableWatchpoint(matched_sp.get(), notify);
 746             m_watchpoint_list.Remove(matched_sp->GetID(), true);
 747         }
 748     }
 749
 750     if (!wp_sp)
 751     {
 752         wp_sp.reset(new Watchpoint(*this, addr, size, type));
 753         wp_sp->SetWatchpointType(kind, notify);
 754         m_watchpoint_list.Add (wp_sp, true);
 755     }
 756
 757     error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify);
 758     if (log)
 759         log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n",
 760                     __FUNCTION__,
 761                     error.Success() ? "succeeded" : "failed",
 762                     wp_sp->GetID());
 763
 764     if (error.Fail())
 765     {
 766         // Enabling the watchpoint on the device side failed.
 767         // Remove the said watchpoint from the list maintained by the target instance.
 768         m_watchpoint_list.Remove (wp_sp->GetID(), true);
 769         // See if we could provide more helpful error message.
 770         if (!CheckIfWatchpointsExhausted(this, error))
 771         {
 772             if (!OptionGroupWatchpoint::IsWatchSizeSupported(size))
 773                 error.SetErrorStringWithFormat("watch size of %" PRIu64 " is not supported", (uint64_t)size);
 774         }
 775         wp_sp.reset();
 776     }
 777     else
 778         m_last_created_watchpoint = wp_sp;
 779     return wp_sp;
 780 }
 781
 782 void
 783 Target::RemoveAllBreakpoints (bool internal_also)
 784 {
 785     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 786     if (log)
 787         log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
 788
 789     m_breakpoint_list.RemoveAll (true);
 790     if (internal_also)
 791         m_internal_breakpoint_list.RemoveAll (false);
 792
 793     m_last_created_breakpoint.reset();
 794 }
 795
 796 void
 797 Target::DisableAllBreakpoints (bool internal_also)
 798 {
 799     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 800     if (log)
 801         log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
 802
 803     m_breakpoint_list.SetEnabledAll (false);
 804     if (internal_also)
 805         m_internal_breakpoint_list.SetEnabledAll (false);
 806 }
 807
 808 void
 809 Target::EnableAllBreakpoints (bool internal_also)
 810 {
 811     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 812     if (log)
 813         log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
 814
 815     m_breakpoint_list.SetEnabledAll (true);
 816     if (internal_also)
 817         m_internal_breakpoint_list.SetEnabledAll (true);
 818 }
 819
 820 bool
 821 Target::RemoveBreakpointByID (break_id_t break_id)
 822 {
 823     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 824     if (log)
 825         log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
 826
 827     if (DisableBreakpointByID (break_id))
 828     {
 829         if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
 830             m_internal_breakpoint_list.Remove(break_id, false);
 831         else
 832         {
 833             if (m_last_created_breakpoint)
 834             {
 835                 if (m_last_created_breakpoint->GetID() == break_id)
 836                     m_last_created_breakpoint.reset();
 837             }
 838             m_breakpoint_list.Remove(break_id, true);
 839         }
 840         return true;
 841     }
 842     return false;
 843 }
 844
 845 bool
 846 Target::DisableBreakpointByID (break_id_t break_id)
 847 {
 848     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 849     if (log)
 850         log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
 851
 852     BreakpointSP bp_sp;
 853
 854     if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
 855         bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
 856     else
 857         bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
 858     if (bp_sp)
 859     {
 860         bp_sp->SetEnabled (false);
 861         return true;
 862     }
 863     return false;
 864 }
 865
 866 bool
 867 Target::EnableBreakpointByID (break_id_t break_id)
 868 {
 869     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 870     if (log)
 871         log->Printf ("Target::%s (break_id = %i, internal = %s)\n",
 872                      __FUNCTION__,
 873                      break_id,
 874                      LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
 875
 876     BreakpointSP bp_sp;
 877
 878     if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
 879         bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
 880     else
 881         bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
 882
 883     if (bp_sp)
 884     {
 885         bp_sp->SetEnabled (true);
 886         return true;
 887     }
 888     return false;
 889 }
 890
 891 // The flag 'end_to_end', default to true, signifies that the operation is
 892 // performed end to end, for both the debugger and the debuggee.
 893
 894 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
 895 // to end operations.
 896 bool
 897 Target::RemoveAllWatchpoints (bool end_to_end)
 898 {
 899     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
 900     if (log)
 901         log->Printf ("Target::%s\n", __FUNCTION__);
 902
 903     if (!end_to_end) {
 904         m_watchpoint_list.RemoveAll(true);
 905         return true;
 906     }
 907
 908     // Otherwise, it's an end to end operation.
 909
 910     if (!ProcessIsValid())
 911         return false;
 912
 913     size_t num_watchpoints = m_watchpoint_list.GetSize();
 914     for (size_t i = 0; i < num_watchpoints; ++i)
 915     {
 916         WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
 917         if (!wp_sp)
 918             return false;
 919
 920         Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
 921         if (rc.Fail())
 922             return false;
 923     }
 924     m_watchpoint_list.RemoveAll (true);
 925     m_last_created_watchpoint.reset();
 926     return true; // Success!
 927 }
 928
 929 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
 930 // end operations.
 931 bool
 932 Target::DisableAllWatchpoints (bool end_to_end)
 933 {
 934     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
 935     if (log)
 936         log->Printf ("Target::%s\n", __FUNCTION__);
 937
 938     if (!end_to_end) {
 939         m_watchpoint_list.SetEnabledAll(false);
 940         return true;
 941     }
 942
 943     // Otherwise, it's an end to end operation.
 944
 945     if (!ProcessIsValid())
 946         return false;
 947
 948     size_t num_watchpoints = m_watchpoint_list.GetSize();
 949     for (size_t i = 0; i < num_watchpoints; ++i)
 950     {
 951         WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
 952         if (!wp_sp)
 953             return false;
 954
 955         Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
 956         if (rc.Fail())
 957             return false;
 958     }
 959     return true; // Success!
 960 }
 961
 962 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
 963 // end operations.
 964 bool
 965 Target::EnableAllWatchpoints (bool end_to_end)
 966 {
 967     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
 968     if (log)
 969         log->Printf ("Target::%s\n", __FUNCTION__);
 970
 971     if (!end_to_end) {
 972         m_watchpoint_list.SetEnabledAll(true);
 973         return true;
 974     }
 975
 976     // Otherwise, it's an end to end operation.
 977
 978     if (!ProcessIsValid())
 979         return false;
 980
 981     size_t num_watchpoints = m_watchpoint_list.GetSize();
 982     for (size_t i = 0; i < num_watchpoints; ++i)
 983     {
 984         WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
 985         if (!wp_sp)
 986             return false;
 987
 988         Error rc = m_process_sp->EnableWatchpoint(wp_sp.get());
 989         if (rc.Fail())
 990             return false;
 991     }
 992     return true; // Success!
 993 }
 994
 995 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
 996 bool
 997 Target::ClearAllWatchpointHitCounts ()
 998 {
 999     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1000     if (log)
1001         log->Printf ("Target::%s\n", __FUNCTION__);
1002
1003     size_t num_watchpoints = m_watchpoint_list.GetSize();
1004     for (size_t i = 0; i < num_watchpoints; ++i)
1005     {
1006         WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1007         if (!wp_sp)
1008             return false;
1009
1010         wp_sp->ResetHitCount();
1011     }
1012     return true; // Success!
1013 }
1014
1015 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1016 bool
1017 Target::ClearAllWatchpointHistoricValues ()
1018 {
1019     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1020     if (log)
1021         log->Printf ("Target::%s\n", __FUNCTION__);
1022
1023     size_t num_watchpoints = m_watchpoint_list.GetSize();
1024     for (size_t i = 0; i < num_watchpoints; ++i)
1025     {
1026         WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1027         if (!wp_sp)
1028             return false;
1029
1030         wp_sp->ResetHistoricValues();
1031     }
1032     return true; // Success!
1033 }
1034
1035 // Assumption: Caller holds the list mutex lock for m_watchpoint_list
1036 // during these operations.
1037 bool
1038 Target::IgnoreAllWatchpoints (uint32_t ignore_count)
1039 {
1040     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1041     if (log)
1042         log->Printf ("Target::%s\n", __FUNCTION__);
1043
1044     if (!ProcessIsValid())
1045         return false;
1046
1047     size_t num_watchpoints = m_watchpoint_list.GetSize();
1048     for (size_t i = 0; i < num_watchpoints; ++i)
1049     {
1050         WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1051         if (!wp_sp)
1052             return false;
1053
1054         wp_sp->SetIgnoreCount(ignore_count);
1055     }
1056     return true; // Success!
1057 }
1058
1059 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1060 bool
1061 Target::DisableWatchpointByID (lldb::watch_id_t watch_id)
1062 {
1063     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1064     if (log)
1065         log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1066
1067     if (!ProcessIsValid())
1068         return false;
1069
1070     WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
1071     if (wp_sp)
1072     {
1073         Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
1074         if (rc.Success())
1075             return true;
1076
1077         // Else, fallthrough.
1078     }
1079     return false;
1080 }
1081
1082 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1083 bool
1084 Target::EnableWatchpointByID (lldb::watch_id_t watch_id)
1085 {
1086     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1087     if (log)
1088         log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1089
1090     if (!ProcessIsValid())
1091         return false;
1092
1093     WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
1094     if (wp_sp)
1095     {
1096         Error rc = m_process_sp->EnableWatchpoint(wp_sp.get());
1097         if (rc.Success())
1098             return true;
1099
1100         // Else, fallthrough.
1101     }
1102     return false;
1103 }
1104
1105 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1106 bool
1107 Target::RemoveWatchpointByID (lldb::watch_id_t watch_id)
1108 {
1109     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1110     if (log)
1111         log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1112
1113     WatchpointSP watch_to_remove_sp = m_watchpoint_list.FindByID(watch_id);
1114     if (watch_to_remove_sp == m_last_created_watchpoint)
1115         m_last_created_watchpoint.reset();
1116
1117     if (DisableWatchpointByID (watch_id))
1118     {
1119         m_watchpoint_list.Remove(watch_id, true);
1120         return true;
1121     }
1122     return false;
1123 }
1124
1125 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1126 bool
1127 Target::IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count)
1128 {
1129     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1130     if (log)
1131         log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1132
1133     if (!ProcessIsValid())
1134         return false;
1135
1136     WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
1137     if (wp_sp)
1138     {
1139         wp_sp->SetIgnoreCount(ignore_count);
1140         return true;
1141     }
1142     return false;
1143 }
1144
1145 ModuleSP
1146 Target::GetExecutableModule ()
1147 {
1148     // search for the first executable in the module list
1149     for (size_t i = 0; i < m_images.GetSize(); ++i)
1150     {
1151         ModuleSP module_sp = m_images.GetModuleAtIndex (i);
1152         lldb_private::ObjectFile * obj = module_sp->GetObjectFile();
1153         if (obj == nullptr)
1154             continue;
1155         if (obj->GetType() == ObjectFile::Type::eTypeExecutable)
1156             return module_sp;
1157     }
1158     // as fall back return the first module loaded
1159     return m_images.GetModuleAtIndex (0);
1160 }
1161
1162 Module*
1163 Target::GetExecutableModulePointer ()
1164 {
1165     return GetExecutableModule().get();
1166 }
1167
1168 static void
1169 LoadScriptingResourceForModule (const ModuleSP &module_sp, Target *target)
1170 {
1171     Error error;
1172     StreamString feedback_stream;
1173     if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error, &feedback_stream))
1174     {
1175         if (error.AsCString())
1176             target->GetDebugger().GetErrorFile()->Printf("unable to load scripting data for module %s - error reported was %s\n",
1177                                                            module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1178                                                            error.AsCString());
1179     }
1180     if (feedback_stream.GetSize())
1181         target->GetDebugger().GetErrorFile()->Printf("%s\n",
1182                                                      feedback_stream.GetData());
1183 }
1184
1185 void
1186 Target::ClearModules(bool delete_locations)
1187 {
1188     ModulesDidUnload (m_images, delete_locations);
1189     m_section_load_history.Clear();
1190     m_images.Clear();
1191     m_scratch_type_system_map.Clear();
1192     m_ast_importer_sp.reset();
1193 }
1194
1195 void
1196 Target::DidExec ()
1197 {
1198     // When a process exec's we need to know about it so we can do some cleanup.
1199     m_breakpoint_list.RemoveInvalidLocations(m_arch);
1200     m_internal_breakpoint_list.RemoveInvalidLocations(m_arch);
1201 }
1202
1203 void
1204 Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files)
1205 {
1206     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
1207     ClearModules(false);
1208
1209     if (executable_sp)
1210     {
1211         Timer scoped_timer (__PRETTY_FUNCTION__,
1212                             "Target::SetExecutableModule (executable = '%s')",
1213                             executable_sp->GetFileSpec().GetPath().c_str());
1214
1215         m_images.Append(executable_sp); // The first image is our executable file
1216
1217         // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module.
1218         if (!m_arch.IsValid())
1219         {
1220             m_arch = executable_sp->GetArchitecture();
1221             if (log)
1222               log->Printf ("Target::SetExecutableModule setting architecture to %s (%s) based on executable file", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
1223         }
1224
1225         FileSpecList dependent_files;
1226         ObjectFile *executable_objfile = executable_sp->GetObjectFile();
1227
1228         if (executable_objfile && get_dependent_files)
1229         {
1230             executable_objfile->GetDependentModules(dependent_files);
1231             for (uint32_t i=0; i<dependent_files.GetSize(); i++)
1232             {
1233                 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i));
1234                 FileSpec platform_dependent_file_spec;
1235                 if (m_platform_sp)
1236                     m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr, platform_dependent_file_spec);
1237                 else
1238                     platform_dependent_file_spec = dependent_file_spec;
1239
1240                 ModuleSpec module_spec (platform_dependent_file_spec, m_arch);
1241                 ModuleSP image_module_sp(GetSharedModule (module_spec));
1242                 if (image_module_sp)
1243                 {
1244                     ObjectFile *objfile = image_module_sp->GetObjectFile();
1245                     if (objfile)
1246                         objfile->GetDependentModules(dependent_files);
1247                 }
1248             }
1249         }
1250     }
1251 }
1252
1253 bool
1254 Target::SetArchitecture (const ArchSpec &arch_spec)
1255 {
1256     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
1257     bool missing_local_arch = !m_arch.IsValid();
1258     bool replace_local_arch = true;
1259     bool compatible_local_arch = false;
1260     ArchSpec other(arch_spec);
1261
1262     if (!missing_local_arch)
1263     {
1264         if (m_arch.IsCompatibleMatch(arch_spec))
1265         {
1266             other.MergeFrom(m_arch);
1267
1268             if (m_arch.IsCompatibleMatch(other))
1269             {
1270                 compatible_local_arch = true;
1271                 bool arch_changed, vendor_changed, os_changed, os_ver_changed, env_changed;
1272
1273                 m_arch.PiecewiseTripleCompare(other,
1274                                               arch_changed,
1275                                               vendor_changed,
1276                                               os_changed,
1277                                               os_ver_changed,
1278                                               env_changed);
1279
1280                 if (!arch_changed && !vendor_changed && !os_changed)
1281                     replace_local_arch = false;
1282             }
1283         }
1284     }
1285
1286     if (compatible_local_arch || missing_local_arch)
1287     {
1288         // If we haven't got a valid arch spec, or the architectures are compatible
1289         // update the architecture, unless the one we already have is more specified
1290         if (replace_local_arch)
1291             m_arch = other;
1292         if (log)
1293             log->Printf ("Target::SetArchitecture set architecture to %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
1294         return true;
1295     }
1296
1297     // If we have an executable file, try to reset the executable to the desired architecture
1298     if (log)
1299       log->Printf ("Target::SetArchitecture changing architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1300     m_arch = other;
1301     ModuleSP executable_sp = GetExecutableModule ();
1302
1303     ClearModules(true);
1304     // Need to do something about unsetting breakpoints.
1305
1306     if (executable_sp)
1307     {
1308         if (log)
1309           log->Printf("Target::SetArchitecture Trying to select executable file architecture %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1310         ModuleSpec module_spec (executable_sp->GetFileSpec(), other);
1311         Error error = ModuleList::GetSharedModule(module_spec,
1312                                                   executable_sp,
1313                                                   &GetExecutableSearchPaths(),
1314                                                   nullptr,
1315                                                   nullptr);
1316
1317         if (!error.Fail() && executable_sp)
1318         {
1319             SetExecutableModule (executable_sp, true);
1320             return true;
1321         }
1322     }
1323     return false;
1324 }
1325
1326 bool
1327 Target::MergeArchitecture (const ArchSpec &arch_spec)
1328 {
1329     if (arch_spec.IsValid())
1330     {
1331         if (m_arch.IsCompatibleMatch(arch_spec))
1332         {
1333             // The current target arch is compatible with "arch_spec", see if we
1334             // can improve our current architecture using bits from "arch_spec"
1335
1336             // Merge bits from arch_spec into "merged_arch" and set our architecture
1337             ArchSpec merged_arch (m_arch);
1338             merged_arch.MergeFrom (arch_spec);
1339             return SetArchitecture(merged_arch);
1340         }
1341         else
1342         {
1343             // The new architecture is different, we just need to replace it
1344             return SetArchitecture(arch_spec);
1345         }
1346     }
1347     return false;
1348 }
1349
1350 void
1351 Target::WillClearList (const ModuleList& module_list)
1352 {
1353 }
1354
1355 void
1356 Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp)
1357 {
1358     // A module is being added to this target for the first time
1359     if (m_valid)
1360     {
1361         ModuleList my_module_list;
1362         my_module_list.Append(module_sp);
1363         LoadScriptingResourceForModule(module_sp, this);
1364         ModulesDidLoad (my_module_list);
1365     }
1366 }
1367
1368 void
1369 Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp)
1370 {
1371     // A module is being removed from this target.
1372     if (m_valid)
1373     {
1374         ModuleList my_module_list;
1375         my_module_list.Append(module_sp);
1376         ModulesDidUnload (my_module_list, false);
1377     }
1378 }
1379
1380 void
1381 Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp)
1382 {
1383     // A module is replacing an already added module
1384     if (m_valid)
1385     {
1386         m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);
1387         m_internal_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);
1388     }
1389 }
1390
1391 void
1392 Target::ModulesDidLoad (ModuleList &module_list)
1393 {
1394     if (m_valid && module_list.GetSize())
1395     {
1396         m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1397         m_internal_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1398         if (m_process_sp)
1399         {
1400             m_process_sp->ModulesDidLoad (module_list);
1401         }
1402         BroadcastEvent (eBroadcastBitModulesLoaded, new TargetEventData (this->shared_from_this(), module_list));
1403     }
1404 }
1405
1406 void
1407 Target::SymbolsDidLoad (ModuleList &module_list)
1408 {
1409     if (m_valid && module_list.GetSize())
1410     {
1411         if (m_process_sp)
1412         {
1413             LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
1414             if (runtime)
1415             {
1416                 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime;
1417                 objc_runtime->SymbolsDidLoad(module_list);
1418             }
1419         }
1420
1421         m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1422         m_internal_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1423         BroadcastEvent (eBroadcastBitSymbolsLoaded, new TargetEventData (this->shared_from_this(), module_list));
1424     }
1425 }
1426
1427 void
1428 Target::ModulesDidUnload (ModuleList &module_list, bool delete_locations)
1429 {
1430     if (m_valid && module_list.GetSize())
1431     {
1432         UnloadModuleSections (module_list);
1433         m_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations);
1434         m_internal_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations);
1435         BroadcastEvent (eBroadcastBitModulesUnloaded, new TargetEventData (this->shared_from_this(), module_list));
1436     }
1437 }
1438
1439 bool
1440 Target::ModuleIsExcludedForUnconstrainedSearches (const FileSpec &module_file_spec)
1441 {
1442     if (GetBreakpointsConsultPlatformAvoidList())
1443     {
1444         ModuleList matchingModules;
1445         ModuleSpec module_spec (module_file_spec);
1446         size_t num_modules = GetImages().FindModules(module_spec, matchingModules);
1447
1448         // If there is more than one module for this file spec, only return true if ALL the modules are on the
1449         // black list.
1450         if (num_modules > 0)
1451         {
1452             for (size_t i  = 0; i < num_modules; i++)
1453             {
1454                 if (!ModuleIsExcludedForUnconstrainedSearches (matchingModules.GetModuleAtIndex(i)))
1455                     return false;
1456             }
1457             return true;
1458         }
1459     }
1460     return false;
1461 }
1462
1463 bool
1464 Target::ModuleIsExcludedForUnconstrainedSearches (const lldb::ModuleSP &module_sp)
1465 {
1466     if (GetBreakpointsConsultPlatformAvoidList())
1467     {
1468         if (m_platform_sp)
1469             return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches (*this, module_sp);
1470     }
1471     return false;
1472 }
1473
1474 size_t
1475 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error)
1476 {
1477     SectionSP section_sp (addr.GetSection());
1478     if (section_sp)
1479     {
1480         // If the contents of this section are encrypted, the on-disk file is unusable.  Read only from live memory.
1481         if (section_sp->IsEncrypted())
1482         {
1483             error.SetErrorString("section is encrypted");
1484             return 0;
1485         }
1486         ModuleSP module_sp (section_sp->GetModule());
1487         if (module_sp)
1488         {
1489             ObjectFile *objfile = section_sp->GetModule()->GetObjectFile();
1490             if (objfile)
1491             {
1492                 size_t bytes_read = objfile->ReadSectionData (section_sp.get(),
1493                                                               addr.GetOffset(),
1494                                                               dst,
1495                                                               dst_len);
1496                 if (bytes_read > 0)
1497                     return bytes_read;
1498                 else
1499                     error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString());
1500             }
1501             else
1502                 error.SetErrorString("address isn't from a object file");
1503         }
1504         else
1505             error.SetErrorString("address isn't in a module");
1506     }
1507     else
1508         error.SetErrorString("address doesn't contain a section that points to a section in a object file");
1509
1510     return 0;
1511 }
1512
1513 size_t
1514 Target::ReadMemory (const Address& addr,
1515                     bool prefer_file_cache,
1516                     void *dst,
1517                     size_t dst_len,
1518                     Error &error,
1519                     lldb::addr_t *load_addr_ptr)
1520 {
1521     error.Clear();
1522
1523     // if we end up reading this from process memory, we will fill this
1524     // with the actual load address
1525     if (load_addr_ptr)
1526         *load_addr_ptr = LLDB_INVALID_ADDRESS;
1527
1528     size_t bytes_read = 0;
1529
1530     addr_t load_addr = LLDB_INVALID_ADDRESS;
1531     addr_t file_addr = LLDB_INVALID_ADDRESS;
1532     Address resolved_addr;
1533     if (!addr.IsSectionOffset())
1534     {
1535         SectionLoadList &section_load_list = GetSectionLoadList();
1536         if (section_load_list.IsEmpty())
1537         {
1538             // No sections are loaded, so we must assume we are not running
1539             // yet and anything we are given is a file address.
1540             file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address
1541             m_images.ResolveFileAddress (file_addr, resolved_addr);
1542         }
1543         else
1544         {
1545             // We have at least one section loaded. This can be because
1546             // we have manually loaded some sections with "target modules load ..."
1547             // or because we have have a live process that has sections loaded
1548             // through the dynamic loader
1549             load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address
1550             section_load_list.ResolveLoadAddress (load_addr, resolved_addr);
1551         }
1552     }
1553     if (!resolved_addr.IsValid())
1554         resolved_addr = addr;
1555
1556     if (prefer_file_cache)
1557     {
1558         bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error);
1559         if (bytes_read > 0)
1560             return bytes_read;
1561     }
1562
1563     if (ProcessIsValid())
1564     {
1565         if (load_addr == LLDB_INVALID_ADDRESS)
1566             load_addr = resolved_addr.GetLoadAddress (this);
1567
1568         if (load_addr == LLDB_INVALID_ADDRESS)
1569         {
1570             ModuleSP addr_module_sp (resolved_addr.GetModule());
1571             if (addr_module_sp && addr_module_sp->GetFileSpec())
1572                 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded",
1573                                                addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
1574                                                resolved_addr.GetFileAddress(),
1575                                                addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknonw>"));
1576             else
1577                 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress());
1578         }
1579         else
1580         {
1581             bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error);
1582             if (bytes_read != dst_len)
1583             {
1584                 if (error.Success())
1585                 {
1586                     if (bytes_read == 0)
1587                         error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr);
1588                     else
1589                         error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr);
1590                 }
1591             }
1592             if (bytes_read)
1593             {
1594                 if (load_addr_ptr)
1595                     *load_addr_ptr = load_addr;
1596                 return bytes_read;
1597             }
1598             // If the address is not section offset we have an address that
1599             // doesn't resolve to any address in any currently loaded shared
1600             // libraries and we failed to read memory so there isn't anything
1601             // more we can do. If it is section offset, we might be able to
1602             // read cached memory from the object file.
1603             if (!resolved_addr.IsSectionOffset())
1604                 return 0;
1605         }
1606     }
1607
1608     if (!prefer_file_cache && resolved_addr.IsSectionOffset())
1609     {
1610         // If we didn't already try and read from the object file cache, then
1611         // try it after failing to read from the process.
1612         return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error);
1613     }
1614     return 0;
1615 }
1616
1617 size_t
1618 Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error)
1619 {
1620     char buf[256];
1621     out_str.clear();
1622     addr_t curr_addr = addr.GetLoadAddress(this);
1623     Address address(addr);
1624     while (1)
1625     {
1626         size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error);
1627         if (length == 0)
1628             break;
1629         out_str.append(buf, length);
1630         // If we got "length - 1" bytes, we didn't get the whole C string, we
1631         // need to read some more characters
1632         if (length == sizeof(buf) - 1)
1633             curr_addr += length;
1634         else
1635             break;
1636         address = Address(curr_addr);
1637     }
1638     return out_str.size();
1639 }
1640
1641 size_t
1642 Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error)
1643 {
1644     size_t total_cstr_len = 0;
1645     if (dst && dst_max_len)
1646     {
1647         result_error.Clear();
1648         // NULL out everything just to be safe
1649         memset (dst, 0, dst_max_len);
1650         Error error;
1651         addr_t curr_addr = addr.GetLoadAddress(this);
1652         Address address(addr);
1653
1654         // We could call m_process_sp->GetMemoryCacheLineSize() but I don't
1655         // think this really needs to be tied to the memory cache subsystem's
1656         // cache line size, so leave this as a fixed constant.
1657         const size_t cache_line_size = 512;
1658
1659         size_t bytes_left = dst_max_len - 1;
1660         char *curr_dst = dst;
1661
1662         while (bytes_left > 0)
1663         {
1664             addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
1665             addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
1666             size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error);
1667
1668             if (bytes_read == 0)
1669             {
1670                 result_error = error;
1671                 dst[total_cstr_len] = '\0';
1672                 break;
1673             }
1674             const size_t len = strlen(curr_dst);
1675
1676             total_cstr_len += len;
1677
1678             if (len < bytes_to_read)
1679                 break;
1680
1681             curr_dst += bytes_read;
1682             curr_addr += bytes_read;
1683             bytes_left -= bytes_read;
1684             address = Address(curr_addr);
1685         }
1686     }
1687     else
1688     {
1689         if (dst == nullptr)
1690             result_error.SetErrorString("invalid arguments");
1691         else
1692             result_error.Clear();
1693     }
1694     return total_cstr_len;
1695 }
1696
1697 size_t
1698 Target::ReadScalarIntegerFromMemory (const Address& addr,
1699                                      bool prefer_file_cache,
1700                                      uint32_t byte_size,
1701                                      bool is_signed,
1702                                      Scalar &scalar,
1703                                      Error &error)
1704 {
1705     uint64_t uval;
1706
1707     if (byte_size <= sizeof(uval))
1708     {
1709         size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error);
1710         if (bytes_read == byte_size)
1711         {
1712             DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize());
1713             lldb::offset_t offset = 0;
1714             if (byte_size <= 4)
1715                 scalar = data.GetMaxU32 (&offset, byte_size);
1716             else
1717                 scalar = data.GetMaxU64 (&offset, byte_size);
1718
1719             if (is_signed)
1720                 scalar.SignExtend(byte_size * 8);
1721             return bytes_read;
1722         }
1723     }
1724     else
1725     {
1726         error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
1727     }
1728     return 0;
1729 }
1730
1731 uint64_t
1732 Target::ReadUnsignedIntegerFromMemory (const Address& addr,
1733                                        bool prefer_file_cache,
1734                                        size_t integer_byte_size,
1735                                        uint64_t fail_value,
1736                                        Error &error)
1737 {
1738     Scalar scalar;
1739     if (ReadScalarIntegerFromMemory (addr,
1740                                      prefer_file_cache,
1741                                      integer_byte_size,
1742                                      false,
1743                                      scalar,
1744                                      error))
1745         return scalar.ULongLong(fail_value);
1746     return fail_value;
1747 }
1748
1749 bool
1750 Target::ReadPointerFromMemory (const Address& addr,
1751                                bool prefer_file_cache,
1752                                Error &error,
1753                                Address &pointer_addr)
1754 {
1755     Scalar scalar;
1756     if (ReadScalarIntegerFromMemory (addr,
1757                                      prefer_file_cache,
1758                                      m_arch.GetAddressByteSize(),
1759                                      false,
1760                                      scalar,
1761                                      error))
1762     {
1763         addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1764         if (pointer_vm_addr != LLDB_INVALID_ADDRESS)
1765         {
1766             SectionLoadList &section_load_list = GetSectionLoadList();
1767             if (section_load_list.IsEmpty())
1768             {
1769                 // No sections are loaded, so we must assume we are not running
1770                 // yet and anything we are given is a file address.
1771                 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr);
1772             }
1773             else
1774             {
1775                 // We have at least one section loaded. This can be because
1776                 // we have manually loaded some sections with "target modules load ..."
1777                 // or because we have have a live process that has sections loaded
1778                 // through the dynamic loader
1779                 section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr);
1780             }
1781             // We weren't able to resolve the pointer value, so just return
1782             // an address with no section
1783             if (!pointer_addr.IsValid())
1784                 pointer_addr.SetOffset (pointer_vm_addr);
1785             return true;
1786
1787         }
1788     }
1789     return false;
1790 }
1791
1792 ModuleSP
1793 Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr)
1794 {
1795     ModuleSP module_sp;
1796
1797     Error error;
1798
1799     // First see if we already have this module in our module list.  If we do, then we're done, we don't need
1800     // to consult the shared modules list.  But only do this if we are passed a UUID.
1801
1802     if (module_spec.GetUUID().IsValid())
1803         module_sp = m_images.FindFirstModule(module_spec);
1804
1805     if (!module_sp)
1806     {
1807         ModuleSP old_module_sp; // This will get filled in if we have a new version of the library
1808         bool did_create_module = false;
1809
1810         // If there are image search path entries, try to use them first to acquire a suitable image.
1811         if (m_image_search_paths.GetSize())
1812         {
1813             ModuleSpec transformed_spec (module_spec);
1814             if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory()))
1815             {
1816                 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename();
1817                 error = ModuleList::GetSharedModule (transformed_spec,
1818                                                      module_sp,
1819                                                      &GetExecutableSearchPaths(),
1820                                                      &old_module_sp,
1821                                                      &did_create_module);
1822             }
1823         }
1824
1825         if (!module_sp)
1826         {
1827             // If we have a UUID, we can check our global shared module list in case
1828             // we already have it. If we don't have a valid UUID, then we can't since
1829             // the path in "module_spec" will be a platform path, and we will need to
1830             // let the platform find that file. For example, we could be asking for
1831             // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick
1832             // the local copy of "/usr/lib/dyld" since our platform could be a remote
1833             // platform that has its own "/usr/lib/dyld" in an SDK or in a local file
1834             // cache.
1835             if (module_spec.GetUUID().IsValid())
1836             {
1837                 // We have a UUID, it is OK to check the global module list...
1838                 error = ModuleList::GetSharedModule (module_spec,
1839                                                      module_sp,
1840                                                      &GetExecutableSearchPaths(),
1841                                                      &old_module_sp,
1842                                                      &did_create_module);
1843             }
1844
1845             if (!module_sp)
1846             {
1847                 // The platform is responsible for finding and caching an appropriate
1848                 // module in the shared module cache.
1849                 if (m_platform_sp)
1850                 {
1851                     error = m_platform_sp->GetSharedModule (module_spec,
1852                                                             m_process_sp.get(),
1853                                                             module_sp,
1854                                                             &GetExecutableSearchPaths(),
1855                                                             &old_module_sp,
1856                                                             &did_create_module);
1857                 }
1858                 else
1859                 {
1860                     error.SetErrorString("no platform is currently set");
1861                 }
1862             }
1863         }
1864
1865         // We found a module that wasn't in our target list.  Let's make sure that there wasn't an equivalent
1866         // module in the list already, and if there was, let's remove it.
1867         if (module_sp)
1868         {
1869             ObjectFile *objfile = module_sp->GetObjectFile();
1870             if (objfile)
1871             {
1872                 switch (objfile->GetType())
1873                 {
1874                     case ObjectFile::eTypeCoreFile:      /// A core file that has a checkpoint of a program's execution state
1875                     case ObjectFile::eTypeExecutable:    /// A normal executable
1876                     case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable
1877                     case ObjectFile::eTypeObjectFile:    /// An intermediate object file
1878                     case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution
1879                         break;
1880                     case ObjectFile::eTypeDebugInfo:     /// An object file that contains only debug information
1881                         if (error_ptr)
1882                             error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable");
1883                         return ModuleSP();
1884                     case ObjectFile::eTypeStubLibrary:   /// A library that can be linked against but not used for execution
1885                         if (error_ptr)
1886                             error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable");
1887                         return ModuleSP();
1888                     default:
1889                         if (error_ptr)
1890                             error_ptr->SetErrorString("unsupported file type, please specify an executable");
1891                         return ModuleSP();
1892                 }
1893                 // GetSharedModule is not guaranteed to find the old shared module, for instance
1894                 // in the common case where you pass in the UUID, it is only going to find the one
1895                 // module matching the UUID.  In fact, it has no good way to know what the "old module"
1896                 // relevant to this target is, since there might be many copies of a module with this file spec
1897                 // in various running debug sessions, but only one of them will belong to this target.
1898                 // So let's remove the UUID from the module list, and look in the target's module list.
1899                 // Only do this if there is SOMETHING else in the module spec...
1900                 if (!old_module_sp)
1901                 {
1902                     if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty())
1903                     {
1904                         ModuleSpec module_spec_copy(module_spec.GetFileSpec());
1905                         module_spec_copy.GetUUID().Clear();
1906
1907                         ModuleList found_modules;
1908                         size_t num_found = m_images.FindModules (module_spec_copy, found_modules);
1909                         if (num_found == 1)
1910                         {
1911                             old_module_sp = found_modules.GetModuleAtIndex(0);
1912                         }
1913                     }
1914                 }
1915
1916                 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32)
1917                 {
1918                     m_images.ReplaceModule(old_module_sp, module_sp);
1919                     Module *old_module_ptr = old_module_sp.get();
1920                     old_module_sp.reset();
1921                     ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr);
1922                 }
1923                 else
1924                     m_images.Append(module_sp);
1925             }
1926             else
1927                 module_sp.reset();
1928         }
1929     }
1930     if (error_ptr)
1931         *error_ptr = error;
1932     return module_sp;
1933 }
1934
1935 TargetSP
1936 Target::CalculateTarget ()
1937 {
1938     return shared_from_this();
1939 }
1940
1941 ProcessSP
1942 Target::CalculateProcess ()
1943 {
1944     return ProcessSP();
1945 }
1946
1947 ThreadSP
1948 Target::CalculateThread ()
1949 {
1950     return ThreadSP();
1951 }
1952
1953 StackFrameSP
1954 Target::CalculateStackFrame ()
1955 {
1956     return StackFrameSP();
1957 }
1958
1959 void
1960 Target::CalculateExecutionContext (ExecutionContext &exe_ctx)
1961 {
1962     exe_ctx.Clear();
1963     exe_ctx.SetTargetPtr(this);
1964 }
1965
1966 PathMappingList &
1967 Target::GetImageSearchPathList ()
1968 {
1969     return m_image_search_paths;
1970 }
1971
1972 void
1973 Target::ImageSearchPathsChanged(const PathMappingList &path_list,
1974                                 void *baton)
1975 {
1976     Target *target = (Target *)baton;
1977     ModuleSP exe_module_sp (target->GetExecutableModule());
1978     if (exe_module_sp)
1979         target->SetExecutableModule (exe_module_sp, true);
1980 }
1981
1982 TypeSystem *
1983 Target::GetScratchTypeSystemForLanguage (Error *error, lldb::LanguageType language, bool create_on_demand)
1984 {
1985     if (!m_valid)
1986         return nullptr;
1987
1988     if (error)
1989     {
1990         error->Clear();
1991     }
1992
1993     if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all assembly code
1994         || language == eLanguageTypeUnknown)
1995     {
1996         std::set<lldb::LanguageType> languages_for_types;
1997         std::set<lldb::LanguageType> languages_for_expressions;
1998
1999         Language::GetLanguagesSupportingTypeSystems(languages_for_types, languages_for_expressions);
2000
2001         if (languages_for_expressions.count(eLanguageTypeC))
2002         {
2003             language = eLanguageTypeC; // LLDB's default.  Override by setting the target language.
2004         }
2005         else
2006         {
2007             if (languages_for_expressions.empty())
2008             {
2009                 return nullptr;
2010             }
2011             else
2012             {
2013                 language = *languages_for_expressions.begin();
2014             }
2015         }
2016     }
2017
2018     return m_scratch_type_system_map.GetTypeSystemForLanguage(language, this, create_on_demand);
2019 }
2020
2021 PersistentExpressionState *
2022 Target::GetPersistentExpressionStateForLanguage (lldb::LanguageType language)
2023 {
2024     TypeSystem *type_system = GetScratchTypeSystemForLanguage(nullptr, language, true);
2025
2026     if (type_system)
2027     {
2028         return type_system->GetPersistentExpressionState();
2029     }
2030     else
2031     {
2032         return nullptr;
2033     }
2034 }
2035
2036 UserExpression *
2037 Target::GetUserExpressionForLanguage(const char *expr,
2038                                      const char *expr_prefix,
2039                                      lldb::LanguageType language,
2040                                      Expression::ResultType desired_type,
2041                                      const EvaluateExpressionOptions &options,
2042                                      Error &error)
2043 {
2044     Error type_system_error;
2045
2046     TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language);
2047     UserExpression *user_expr = nullptr;
2048
2049     if (!type_system)
2050     {
2051         error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString());
2052         return nullptr;
2053     }
2054
2055     user_expr = type_system->GetUserExpression(expr, expr_prefix, language, desired_type, options);
2056     if (!user_expr)
2057         error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));
2058
2059     return user_expr;
2060 }
2061
2062 FunctionCaller *
2063 Target::GetFunctionCallerForLanguage (lldb::LanguageType language,
2064                                       const CompilerType &return_type,
2065                                       const Address& function_address,
2066                                       const ValueList &arg_value_list,
2067                                       const char *name,
2068                                       Error &error)
2069 {
2070     Error type_system_error;
2071     TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language);
2072     FunctionCaller *persistent_fn = nullptr;
2073
2074     if (!type_system)
2075     {
2076         error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString());
2077         return persistent_fn;
2078     }
2079
2080     persistent_fn = type_system->GetFunctionCaller (return_type, function_address, arg_value_list, name);
2081     if (!persistent_fn)
2082         error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));
2083
2084     return persistent_fn;
2085 }
2086
2087 UtilityFunction *
2088 Target::GetUtilityFunctionForLanguage (const char *text,
2089                                        lldb::LanguageType language,
2090                                        const char *name,
2091                                        Error &error)
2092 {
2093     Error type_system_error;
2094     TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language);
2095     UtilityFunction *utility_fn = nullptr;
2096
2097     if (!type_system)
2098     {
2099         error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString());
2100         return utility_fn;
2101     }
2102
2103     utility_fn = type_system->GetUtilityFunction (text, name);
2104     if (!utility_fn)
2105         error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));
2106
2107     return utility_fn;
2108 }
2109
2110 ClangASTContext *
2111 Target::GetScratchClangASTContext(bool create_on_demand)
2112 {
2113     if (m_valid)
2114     {
2115         if (TypeSystem* type_system = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC, create_on_demand))
2116             return llvm::dyn_cast<ClangASTContext>(type_system);
2117     }
2118     return nullptr;
2119 }
2120
2121 ClangASTImporterSP
2122 Target::GetClangASTImporter()
2123 {
2124     if (m_valid)
2125     {
2126         if (!m_ast_importer_sp)
2127         {
2128             m_ast_importer_sp.reset(new ClangASTImporter());
2129         }
2130         return m_ast_importer_sp;
2131     }
2132     return ClangASTImporterSP();
2133 }
2134
2135 void
2136 Target::SettingsInitialize ()
2137 {
2138     Process::SettingsInitialize ();
2139 }
2140
2141 void
2142 Target::SettingsTerminate ()
2143 {
2144     Process::SettingsTerminate ();
2145 }
2146
2147 FileSpecList
2148 Target::GetDefaultExecutableSearchPaths ()
2149 {
2150     TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2151     if (properties_sp)
2152         return properties_sp->GetExecutableSearchPaths();
2153     return FileSpecList();
2154 }
2155
2156 FileSpecList
2157 Target::GetDefaultDebugFileSearchPaths ()
2158 {
2159     TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2160     if (properties_sp)
2161         return properties_sp->GetDebugFileSearchPaths();
2162     return FileSpecList();
2163 }
2164
2165 FileSpecList
2166 Target::GetDefaultClangModuleSearchPaths ()
2167 {
2168     TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2169     if (properties_sp)
2170         return properties_sp->GetClangModuleSearchPaths();
2171     return FileSpecList();
2172 }
2173
2174 ArchSpec
2175 Target::GetDefaultArchitecture ()
2176 {
2177     TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2178     if (properties_sp)
2179         return properties_sp->GetDefaultArchitecture();
2180     return ArchSpec();
2181 }
2182
2183 void
2184 Target::SetDefaultArchitecture (const ArchSpec &arch)
2185 {
2186     TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2187     if (properties_sp)
2188     {
2189         LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to  %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str());
2190         return properties_sp->SetDefaultArchitecture(arch);
2191     }
2192 }
2193
2194 Target *
2195 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr)
2196 {
2197     // The target can either exist in the "process" of ExecutionContext, or in
2198     // the "target_sp" member of SymbolContext. This accessor helper function
2199     // will get the target from one of these locations.
2200
2201     Target *target = nullptr;
2202     if (sc_ptr != nullptr)
2203         target = sc_ptr->target_sp.get();
2204     if (target == nullptr && exe_ctx_ptr)
2205         target = exe_ctx_ptr->GetTargetPtr();
2206     return target;
2207 }
2208
2209 ExpressionResults
2210 Target::EvaluateExpression(const char *expr_cstr,
2211                            ExecutionContextScope *exe_scope,
2212                            lldb::ValueObjectSP &result_valobj_sp,
2213                            const EvaluateExpressionOptions& options)
2214 {
2215     result_valobj_sp.reset();
2216
2217     ExpressionResults execution_results = eExpressionSetupError;
2218
2219     if (expr_cstr == nullptr || expr_cstr[0] == '\0')
2220         return execution_results;
2221
2222     // We shouldn't run stop hooks in expressions.
2223     // Be sure to reset this if you return anywhere within this function.
2224     bool old_suppress_value = m_suppress_stop_hooks;
2225     m_suppress_stop_hooks = true;
2226
2227     ExecutionContext exe_ctx;
2228
2229     if (exe_scope)
2230     {
2231         exe_scope->CalculateExecutionContext(exe_ctx);
2232     }
2233     else if (m_process_sp)
2234     {
2235         m_process_sp->CalculateExecutionContext(exe_ctx);
2236     }
2237     else
2238     {
2239         CalculateExecutionContext(exe_ctx);
2240     }
2241
2242     // Make sure we aren't just trying to see the value of a persistent
2243     // variable (something like "$0")
2244     lldb::ExpressionVariableSP persistent_var_sp;
2245     // Only check for persistent variables the expression starts with a '$'
2246     if (expr_cstr[0] == '$')
2247         persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC)->GetPersistentExpressionState()->GetVariable (expr_cstr);
2248
2249     if (persistent_var_sp)
2250     {
2251         result_valobj_sp = persistent_var_sp->GetValueObject ();
2252         execution_results = eExpressionCompleted;
2253     }
2254     else
2255     {
2256         const char *prefix = GetExpressionPrefixContentsAsCString();
2257         Error error;
2258         execution_results = UserExpression::Evaluate (exe_ctx,
2259                                                       options,
2260                                                       expr_cstr,
2261                                                       prefix,
2262                                                       result_valobj_sp,
2263                                                       error);
2264     }
2265
2266     m_suppress_stop_hooks = old_suppress_value;
2267
2268     return execution_results;
2269 }
2270
2271 lldb::ExpressionVariableSP
2272 Target::GetPersistentVariable(const ConstString &name)
2273 {
2274     lldb::ExpressionVariableSP variable_sp;
2275     m_scratch_type_system_map.ForEach([this, name, &variable_sp](TypeSystem *type_system) -> bool
2276     {
2277         if (PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState())
2278         {
2279             variable_sp = persistent_state->GetVariable(name);
2280
2281             if (variable_sp)
2282                 return false;   // Stop iterating the ForEach
2283         }
2284         return true;    // Keep iterating the ForEach
2285     });
2286     return variable_sp;
2287 }
2288
2289 lldb::addr_t
2290 Target::GetPersistentSymbol(const ConstString &name)
2291 {
2292     lldb::addr_t address = LLDB_INVALID_ADDRESS;
2293
2294     m_scratch_type_system_map.ForEach([this, name, &address](TypeSystem *type_system) -> bool
2295     {
2296         if (PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState())
2297         {
2298             address = persistent_state->LookupSymbol(name);
2299             if (address != LLDB_INVALID_ADDRESS)
2300                 return false;   // Stop iterating the ForEach
2301         }
2302         return true;    // Keep iterating the ForEach
2303     });
2304     return address;
2305 }
2306
2307 lldb::addr_t
2308 Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const
2309 {
2310     addr_t code_addr = load_addr;
2311     switch (m_arch.GetMachine())
2312     {
2313     case llvm::Triple::mips:
2314     case llvm::Triple::mipsel:
2315     case llvm::Triple::mips64:
2316     case llvm::Triple::mips64el:
2317         switch (addr_class)
2318         {
2319         case eAddressClassData:
2320         case eAddressClassDebug:
2321             return LLDB_INVALID_ADDRESS;
2322
2323         case eAddressClassUnknown:
2324         case eAddressClassInvalid:
2325         case eAddressClassCode:
2326         case eAddressClassCodeAlternateISA:
2327         case eAddressClassRuntime:
2328             if ((code_addr & 2ull) || (addr_class == eAddressClassCodeAlternateISA))
2329                 code_addr |= 1ull;
2330             break;
2331         }
2332         break;
2333
2334     case llvm::Triple::arm:
2335     case llvm::Triple::thumb:
2336         switch (addr_class)
2337         {
2338         case eAddressClassData:
2339         case eAddressClassDebug:
2340             return LLDB_INVALID_ADDRESS;
2341
2342         case eAddressClassUnknown:
2343         case eAddressClassInvalid:
2344         case eAddressClassCode:
2345         case eAddressClassCodeAlternateISA:
2346         case eAddressClassRuntime:
2347             // Check if bit zero it no set?
2348             if ((code_addr & 1ull) == 0)
2349             {
2350                 // Bit zero isn't set, check if the address is a multiple of 2?
2351                 if (code_addr & 2ull)
2352                 {
2353                     // The address is a multiple of 2 so it must be thumb, set bit zero
2354                     code_addr |= 1ull;
2355                 }
2356                 else if (addr_class == eAddressClassCodeAlternateISA)
2357                 {
2358                     // We checked the address and the address claims to be the alternate ISA
2359                     // which means thumb, so set bit zero.
2360                     code_addr |= 1ull;
2361                 }
2362             }
2363             break;
2364         }
2365         break;
2366
2367     default:
2368         break;
2369     }
2370     return code_addr;
2371 }
2372
2373 lldb::addr_t
2374 Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const
2375 {
2376     addr_t opcode_addr = load_addr;
2377     switch (m_arch.GetMachine())
2378     {
2379     case llvm::Triple::mips:
2380     case llvm::Triple::mipsel:
2381     case llvm::Triple::mips64:
2382     case llvm::Triple::mips64el:
2383     case llvm::Triple::arm:
2384     case llvm::Triple::thumb:
2385         switch (addr_class)
2386         {
2387         case eAddressClassData:
2388         case eAddressClassDebug:
2389             return LLDB_INVALID_ADDRESS;
2390
2391         case eAddressClassInvalid:
2392         case eAddressClassUnknown:
2393         case eAddressClassCode:
2394         case eAddressClassCodeAlternateISA:
2395         case eAddressClassRuntime:
2396             opcode_addr &= ~(1ull);
2397             break;
2398         }
2399         break;
2400
2401     default:
2402         break;
2403     }
2404     return opcode_addr;
2405 }
2406
2407 lldb::addr_t
2408 Target::GetBreakableLoadAddress (lldb::addr_t addr)
2409 {
2410     addr_t breakable_addr = addr;
2411     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
2412
2413     switch (m_arch.GetMachine())
2414     {
2415     default:
2416         break;
2417     case llvm::Triple::mips:
2418     case llvm::Triple::mipsel:
2419     case llvm::Triple::mips64:
2420     case llvm::Triple::mips64el:
2421     {
2422         addr_t function_start = 0;
2423         addr_t current_offset = 0;
2424         uint32_t loop_count = 0;
2425         Address resolved_addr;
2426         uint32_t arch_flags = m_arch.GetFlags ();
2427         bool IsMips16 = arch_flags & ArchSpec::eMIPSAse_mips16;
2428         bool IsMicromips = arch_flags & ArchSpec::eMIPSAse_micromips;
2429         SectionLoadList &section_load_list = GetSectionLoadList();
2430
2431         if (section_load_list.IsEmpty())
2432             // No sections are loaded, so we must assume we are not running yet
2433             // and need to operate only on file address.
2434             m_images.ResolveFileAddress (addr, resolved_addr);
2435         else
2436             section_load_list.ResolveLoadAddress(addr, resolved_addr);
2437
2438         // Get the function boundaries to make sure we don't scan back before the beginning of the current function.
2439         ModuleSP temp_addr_module_sp (resolved_addr.GetModule());
2440         if (temp_addr_module_sp)
2441         {
2442             SymbolContext sc;
2443             uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
2444             temp_addr_module_sp->ResolveSymbolContextForAddress(resolved_addr, resolve_scope, sc);
2445             if (sc.function)
2446             {
2447                 function_start = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(this);
2448                 if (function_start == LLDB_INVALID_ADDRESS)
2449                     function_start = sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
2450             }
2451             else if (sc.symbol)
2452             {
2453                 Address sym_addr = sc.symbol->GetAddress();
2454                 function_start = sym_addr.GetFileAddress();
2455             }
2456             current_offset = addr - function_start;
2457         }
2458
2459         // If breakpoint address is start of function then we dont have to do anything.
2460         if (current_offset == 0)
2461             return breakable_addr;
2462         else
2463             loop_count = current_offset / 2;
2464
2465         if (loop_count > 3)
2466         {
2467             // Scan previous 6 bytes
2468             if (IsMips16 | IsMicromips)
2469                 loop_count = 3;
2470             // For mips-only, instructions are always 4 bytes, so scan previous 4 bytes only.
2471             else
2472                 loop_count = 2;
2473         }
2474
2475         // Create Disassembler Instance
2476         lldb::DisassemblerSP disasm_sp(Disassembler::FindPlugin(m_arch, nullptr, nullptr));
2477
2478         ExecutionContext exe_ctx;
2479         CalculateExecutionContext(exe_ctx);
2480         InstructionList instruction_list;
2481         InstructionSP prev_insn;
2482         bool prefer_file_cache = true; // Read from file
2483         uint32_t inst_to_choose = 0;
2484
2485         for (uint32_t i = 1; i <= loop_count; i++)
2486         {
2487             // Adjust the address to read from.
2488             resolved_addr.Slide (-2);
2489             AddressRange range(resolved_addr, i*2);
2490             uint32_t insn_size = 0;
2491
2492             disasm_sp->ParseInstructions(&exe_ctx, range, nullptr, prefer_file_cache);
2493
2494             uint32_t num_insns = disasm_sp->GetInstructionList().GetSize();
2495             if (num_insns)
2496             {
2497                 prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0);
2498                 insn_size = prev_insn->GetOpcode().GetByteSize();
2499                 if (i == 1 && insn_size == 2)
2500                 {
2501                     // This looks like a valid 2-byte instruction (but it could be a part of upper 4 byte instruction).
2502                     instruction_list.Append(prev_insn);
2503                     inst_to_choose = 1;
2504                 }
2505                 else if (i == 2)
2506                 {
2507                     // Here we may get one 4-byte instruction or two 2-byte instructions.
2508                     if (num_insns == 2)
2509                     {
2510                         // Looks like there are two 2-byte instructions above our breakpoint target address.
2511                         // Now the upper 2-byte instruction is either a valid 2-byte instruction or could be a part of it's upper 4-byte instruction.
2512                         // In both cases we don't care because in this case lower 2-byte instruction is definitely a valid instruction
2513                         // and whatever i=1 iteration has found out is true.
2514                         inst_to_choose = 1;
2515                         break;
2516                     }
2517                     else if (insn_size == 4)
2518                     {
2519                         // This instruction claims its a valid 4-byte instruction. But it could be a part of it's upper 4-byte instruction.
2520                         // Lets try scanning upper 2 bytes to verify this.
2521                         instruction_list.Append(prev_insn);
2522                         inst_to_choose = 2;
2523                     }
2524                 }
2525                 else if (i == 3)
2526                 {
2527                     if (insn_size == 4)
2528                         // FIXME: We reached here that means instruction at [target - 4] has already claimed to be a 4-byte instruction,
2529                         // and now instruction at [target - 6] is also claiming that it's a 4-byte instruction. This can not be true.
2530                         // In this case we can not decide the valid previous instruction so we let lldb set the breakpoint at the address given by user.
2531                         inst_to_choose = 0;
2532                     else
2533                         // This is straight-forward
2534                         inst_to_choose = 2;
2535                     break;
2536                 }
2537             }
2538             else
2539             {
2540                 // Decode failed, bytes do not form a valid instruction. So whatever previous iteration has found out is true.
2541                 if (i > 1)
2542                 {
2543                     inst_to_choose = i - 1;
2544                     break;
2545                 }
2546             }
2547         }
2548
2549         // Check if we are able to find any valid instruction.
2550         if (inst_to_choose)
2551         {
2552             if (inst_to_choose > instruction_list.GetSize())
2553                 inst_to_choose--;
2554             prev_insn = instruction_list.GetInstructionAtIndex(inst_to_choose - 1);
2555
2556             if (prev_insn->HasDelaySlot())
2557             {
2558                 uint32_t shift_size = prev_insn->GetOpcode().GetByteSize();
2559                 // Adjust the breakable address
2560                 breakable_addr = addr - shift_size;
2561                 if (log)
2562                     log->Printf ("Target::%s Breakpoint at 0x%8.8" PRIx64 " is adjusted to 0x%8.8" PRIx64 " due to delay slot\n", __FUNCTION__, addr, breakable_addr);
2563             }
2564         }
2565         break;
2566     }
2567     }
2568     return breakable_addr;
2569 }
2570
2571 SourceManager &
2572 Target::GetSourceManager ()
2573 {
2574     if (!m_source_manager_ap)
2575         m_source_manager_ap.reset (new SourceManager(shared_from_this()));
2576     return *m_source_manager_ap;
2577 }
2578
2579 ClangModulesDeclVendor *
2580 Target::GetClangModulesDeclVendor ()
2581 {
2582     static Mutex s_clang_modules_decl_vendor_mutex; // If this is contended we can make it per-target
2583
2584     {
2585         Mutex::Locker clang_modules_decl_vendor_locker(s_clang_modules_decl_vendor_mutex);
2586
2587         if (!m_clang_modules_decl_vendor_ap)
2588         {
2589             m_clang_modules_decl_vendor_ap.reset(ClangModulesDeclVendor::Create(*this));
2590         }
2591     }
2592
2593     return m_clang_modules_decl_vendor_ap.get();
2594 }
2595
2596 Target::StopHookSP
2597 Target::CreateStopHook ()
2598 {
2599     lldb::user_id_t new_uid = ++m_stop_hook_next_id;
2600     Target::StopHookSP stop_hook_sp (new StopHook(shared_from_this(), new_uid));
2601     m_stop_hooks[new_uid] = stop_hook_sp;
2602     return stop_hook_sp;
2603 }
2604
2605 bool
2606 Target::RemoveStopHookByID (lldb::user_id_t user_id)
2607 {
2608     size_t num_removed = m_stop_hooks.erase(user_id);
2609     return (num_removed != 0);
2610 }
2611
2612 void
2613 Target::RemoveAllStopHooks ()
2614 {
2615     m_stop_hooks.clear();
2616 }
2617
2618 Target::StopHookSP
2619 Target::GetStopHookByID (lldb::user_id_t user_id)
2620 {
2621     StopHookSP found_hook;
2622
2623     StopHookCollection::iterator specified_hook_iter;
2624     specified_hook_iter = m_stop_hooks.find (user_id);
2625     if (specified_hook_iter != m_stop_hooks.end())
2626         found_hook = (*specified_hook_iter).second;
2627     return found_hook;
2628 }
2629
2630 bool
2631 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state)
2632 {
2633     StopHookCollection::iterator specified_hook_iter;
2634     specified_hook_iter = m_stop_hooks.find (user_id);
2635     if (specified_hook_iter == m_stop_hooks.end())
2636         return false;
2637
2638     (*specified_hook_iter).second->SetIsActive (active_state);
2639     return true;
2640 }
2641
2642 void
2643 Target::SetAllStopHooksActiveState (bool active_state)
2644 {
2645     StopHookCollection::iterator pos, end = m_stop_hooks.end();
2646     for (pos = m_stop_hooks.begin(); pos != end; pos++)
2647     {
2648         (*pos).second->SetIsActive (active_state);
2649     }
2650 }
2651
2652 void
2653 Target::RunStopHooks ()
2654 {
2655     if (m_suppress_stop_hooks)
2656         return;
2657
2658     if (!m_process_sp)
2659         return;
2660
2661     // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression
2662     // since in that case we do not want to run the stop-hooks
2663     if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
2664         return;
2665
2666     if (m_stop_hooks.empty())
2667         return;
2668
2669     StopHookCollection::iterator pos, end = m_stop_hooks.end();
2670
2671     // If there aren't any active stop hooks, don't bother either:
2672     bool any_active_hooks = false;
2673     for (pos = m_stop_hooks.begin(); pos != end; pos++)
2674     {
2675         if ((*pos).second->IsActive())
2676         {
2677             any_active_hooks = true;
2678             break;
2679         }
2680     }
2681     if (!any_active_hooks)
2682         return;
2683
2684     CommandReturnObject result;
2685
2686     std::vector<ExecutionContext> exc_ctx_with_reasons;
2687     std::vector<SymbolContext> sym_ctx_with_reasons;
2688
2689     ThreadList &cur_threadlist = m_process_sp->GetThreadList();
2690     size_t num_threads = cur_threadlist.GetSize();
2691     for (size_t i = 0; i < num_threads; i++)
2692     {
2693         lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i);
2694         if (cur_thread_sp->ThreadStoppedForAReason())
2695         {
2696             lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
2697             exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get()));
2698             sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
2699         }
2700     }
2701
2702     // If no threads stopped for a reason, don't run the stop-hooks.
2703     size_t num_exe_ctx = exc_ctx_with_reasons.size();
2704     if (num_exe_ctx == 0)
2705         return;
2706
2707     result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream());
2708     result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream());
2709
2710     bool keep_going = true;
2711     bool hooks_ran = false;
2712     bool print_hook_header = (m_stop_hooks.size() != 1);
2713     bool print_thread_header = (num_exe_ctx != 1);
2714
2715     for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++)
2716     {
2717         // result.Clear();
2718         StopHookSP cur_hook_sp = (*pos).second;
2719         if (!cur_hook_sp->IsActive())
2720             continue;
2721
2722         bool any_thread_matched = false;
2723         for (size_t i = 0; keep_going && i < num_exe_ctx; i++)
2724         {
2725             if ((cur_hook_sp->GetSpecifier() == nullptr
2726                   || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i]))
2727                 && (cur_hook_sp->GetThreadSpecifier() == nullptr
2728                     || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef())))
2729             {
2730                 if (!hooks_ran)
2731                 {
2732                     hooks_ran = true;
2733                 }
2734                 if (print_hook_header && !any_thread_matched)
2735                 {
2736                     const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ?
2737                                        cur_hook_sp->GetCommands().GetStringAtIndex(0) :
2738                                        nullptr);
2739                     if (cmd)
2740                         result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd);
2741                     else
2742                         result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID());
2743                     any_thread_matched = true;
2744                 }
2745
2746                 if (print_thread_header)
2747                     result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID());
2748
2749                 CommandInterpreterRunOptions options;
2750                 options.SetStopOnContinue (true);
2751                 options.SetStopOnError (true);
2752                 options.SetEchoCommands (false);
2753                 options.SetPrintResults (true);
2754                 options.SetAddToHistory (false);
2755
2756                 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(),
2757                                                                       &exc_ctx_with_reasons[i],
2758                                                                       options,
2759                                                                       result);
2760
2761                 // If the command started the target going again, we should bag out of
2762                 // running the stop hooks.
2763                 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
2764                     (result.GetStatus() == eReturnStatusSuccessContinuingResult))
2765                 {
2766                     result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID());
2767                     keep_going = false;
2768                 }
2769             }
2770         }
2771     }
2772
2773     result.GetImmediateOutputStream()->Flush();
2774     result.GetImmediateErrorStream()->Flush();
2775 }
2776
2777 const TargetPropertiesSP &
2778 Target::GetGlobalProperties()
2779 {
2780     static TargetPropertiesSP g_settings_sp;
2781     if (!g_settings_sp)
2782     {
2783         g_settings_sp.reset(new TargetProperties(nullptr));
2784     }
2785     return g_settings_sp;
2786 }
2787
2788 Error
2789 Target::Install (ProcessLaunchInfo *launch_info)
2790 {
2791     Error error;
2792     PlatformSP platform_sp (GetPlatform());
2793     if (platform_sp)
2794     {
2795         if (platform_sp->IsRemote())
2796         {
2797             if (platform_sp->IsConnected())
2798             {
2799                 // Install all files that have an install path, and always install the
2800                 // main executable when connected to a remote platform
2801                 const ModuleList& modules = GetImages();
2802                 const size_t num_images = modules.GetSize();
2803                 for (size_t idx = 0; idx < num_images; ++idx)
2804                 {
2805                     const bool is_main_executable = idx == 0;
2806                     ModuleSP module_sp(modules.GetModuleAtIndex(idx));
2807                     if (module_sp)
2808                     {
2809                         FileSpec local_file (module_sp->GetFileSpec());
2810                         if (local_file)
2811                         {
2812                             FileSpec remote_file (module_sp->GetRemoteInstallFileSpec());
2813                             if (!remote_file)
2814                             {
2815                                 if (is_main_executable) // TODO: add setting for always installing main executable???
2816                                 {
2817                                     // Always install the main executable
2818                                     remote_file = platform_sp->GetRemoteWorkingDirectory();
2819                                     remote_file.AppendPathComponent(module_sp->GetFileSpec().GetFilename().GetCString());
2820                                 }
2821                             }
2822                             if (remote_file)
2823                             {
2824                                 error = platform_sp->Install(local_file, remote_file);
2825                                 if (error.Success())
2826                                 {
2827                                     module_sp->SetPlatformFileSpec(remote_file);
2828                                     if (is_main_executable)
2829                                     {
2830                                         platform_sp->SetFilePermissions(remote_file, 0700);
2831                                         if (launch_info)
2832                                             launch_info->SetExecutableFile(remote_file, false);
2833                                     }
2834                                 }
2835                                 else
2836                                     break;
2837                             }
2838                         }
2839                     }
2840                 }
2841             }
2842         }
2843     }
2844     return error;
2845 }
2846
2847 bool
2848 Target::ResolveLoadAddress (addr_t load_addr, Address &so_addr, uint32_t stop_id)
2849 {
2850     return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr);
2851 }
2852
2853 bool
2854 Target::ResolveFileAddress (lldb::addr_t file_addr, Address &resolved_addr)
2855 {
2856     return m_images.ResolveFileAddress(file_addr, resolved_addr);
2857 }
2858
2859 bool
2860 Target::SetSectionLoadAddress (const SectionSP &section_sp, addr_t new_section_load_addr, bool warn_multiple)
2861 {
2862     const addr_t old_section_load_addr = m_section_load_history.GetSectionLoadAddress (SectionLoadHistory::eStopIDNow, section_sp);
2863     if (old_section_load_addr != new_section_load_addr)
2864     {
2865         uint32_t stop_id = 0;
2866         ProcessSP process_sp(GetProcessSP());
2867         if (process_sp)
2868             stop_id = process_sp->GetStopID();
2869         else
2870             stop_id = m_section_load_history.GetLastStopID();
2871         if (m_section_load_history.SetSectionLoadAddress (stop_id, section_sp, new_section_load_addr, warn_multiple))
2872             return true; // Return true if the section load address was changed...
2873     }
2874     return false; // Return false to indicate nothing changed
2875 }
2876
2877 size_t
2878 Target::UnloadModuleSections (const ModuleList &module_list)
2879 {
2880     size_t section_unload_count = 0;
2881     size_t num_modules = module_list.GetSize();
2882     for (size_t i=0; i<num_modules; ++i)
2883     {
2884         section_unload_count += UnloadModuleSections (module_list.GetModuleAtIndex(i));
2885     }
2886     return section_unload_count;
2887 }
2888
2889 size_t
2890 Target::UnloadModuleSections (const lldb::ModuleSP &module_sp)
2891 {
2892     uint32_t stop_id = 0;
2893     ProcessSP process_sp(GetProcessSP());
2894     if (process_sp)
2895         stop_id = process_sp->GetStopID();
2896     else
2897         stop_id = m_section_load_history.GetLastStopID();
2898     SectionList *sections = module_sp->GetSectionList();
2899     size_t section_unload_count = 0;
2900     if (sections)
2901     {
2902         const uint32_t num_sections = sections->GetNumSections(0);
2903         for (uint32_t i = 0; i < num_sections; ++i)
2904         {
2905             section_unload_count += m_section_load_history.SetSectionUnloaded(stop_id, sections->GetSectionAtIndex(i));
2906         }
2907     }
2908     return section_unload_count;
2909 }
2910
2911 bool
2912 Target::SetSectionUnloaded (const lldb::SectionSP &section_sp)
2913 {
2914     uint32_t stop_id = 0;
2915     ProcessSP process_sp(GetProcessSP());
2916     if (process_sp)
2917         stop_id = process_sp->GetStopID();
2918     else
2919         stop_id = m_section_load_history.GetLastStopID();
2920     return m_section_load_history.SetSectionUnloaded (stop_id, section_sp);
2921 }
2922
2923 bool
2924 Target::SetSectionUnloaded (const lldb::SectionSP &section_sp, addr_t load_addr)
2925 {
2926     uint32_t stop_id = 0;
2927     ProcessSP process_sp(GetProcessSP());
2928     if (process_sp)
2929         stop_id = process_sp->GetStopID();
2930     else
2931         stop_id = m_section_load_history.GetLastStopID();
2932     return m_section_load_history.SetSectionUnloaded (stop_id, section_sp, load_addr);
2933 }
2934
2935 void
2936 Target::ClearAllLoadedSections ()
2937 {
2938     m_section_load_history.Clear();
2939 }
2940
2941 Error
2942 Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream)
2943 {
2944     Error error;
2945     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
2946
2947     if (log)
2948         log->Printf ("Target::%s() called for %s", __FUNCTION__, launch_info.GetExecutableFile().GetPath().c_str ());
2949
2950     StateType state = eStateInvalid;
2951
2952     // Scope to temporarily get the process state in case someone has manually
2953     // remotely connected already to a process and we can skip the platform
2954     // launching.
2955     {
2956         ProcessSP process_sp (GetProcessSP());
2957
2958         if (process_sp)
2959         {
2960             state = process_sp->GetState();
2961             if (log)
2962                 log->Printf ("Target::%s the process exists, and its current state is %s", __FUNCTION__, StateAsCString (state));
2963         }
2964         else
2965         {
2966             if (log)
2967                 log->Printf ("Target::%s the process instance doesn't currently exist.", __FUNCTION__);
2968         }
2969     }
2970
2971     launch_info.GetFlags().Set (eLaunchFlagDebug);
2972
2973     // Get the value of synchronous execution here.  If you wait till after you have started to
2974     // run, then you could have hit a breakpoint, whose command might switch the value, and
2975     // then you'll pick up that incorrect value.
2976     Debugger &debugger = GetDebugger();
2977     const bool synchronous_execution = debugger.GetCommandInterpreter().GetSynchronous ();
2978
2979     PlatformSP platform_sp (GetPlatform());
2980
2981     // Finalize the file actions, and if none were given, default to opening
2982     // up a pseudo terminal
2983     const bool default_to_use_pty = platform_sp ? platform_sp->IsHost() : false;
2984     if (log)
2985         log->Printf ("Target::%s have platform=%s, platform_sp->IsHost()=%s, default_to_use_pty=%s",
2986                      __FUNCTION__,
2987                      platform_sp ? "true" : "false",
2988                      platform_sp ? (platform_sp->IsHost () ? "true" : "false") : "n/a",
2989                      default_to_use_pty ? "true" : "false");
2990
2991     launch_info.FinalizeFileActions (this, default_to_use_pty);
2992
2993     if (state == eStateConnected)
2994     {
2995         if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY))
2996         {
2997             error.SetErrorString("can't launch in tty when launching through a remote connection");
2998             return error;
2999         }
3000     }
3001
3002     if (!launch_info.GetArchitecture().IsValid())
3003         launch_info.GetArchitecture() = GetArchitecture();
3004
3005     // If we're not already connected to the process, and if we have a platform that can launch a process for debugging, go ahead and do that here.
3006     if (state != eStateConnected && platform_sp && platform_sp->CanDebugProcess ())
3007     {
3008         if (log)
3009             log->Printf ("Target::%s asking the platform to debug the process", __FUNCTION__);
3010
3011         // Get a weak pointer to the previous process if we have one
3012         ProcessWP process_wp;
3013         if (m_process_sp)
3014             process_wp = m_process_sp;
3015         m_process_sp = GetPlatform()->DebugProcess (launch_info,
3016                                                     debugger,
3017                                                     this,
3018                                                     error);
3019
3020         // Cleanup the old process since someone might still have a strong
3021         // reference to this process and we would like to allow it to cleanup
3022         // as much as it can without the object being destroyed. We try to
3023         // lock the shared pointer and if that works, then someone else still
3024         // has a strong reference to the process.
3025
3026         ProcessSP old_process_sp(process_wp.lock());
3027         if (old_process_sp)
3028             old_process_sp->Finalize();
3029     }
3030     else
3031     {
3032         if (log)
3033             log->Printf ("Target::%s the platform doesn't know how to debug a process, getting a process plugin to do this for us.", __FUNCTION__);
3034
3035         if (state == eStateConnected)
3036         {
3037             assert(m_process_sp);
3038         }
3039         else
3040         {
3041             // Use a Process plugin to construct the process.
3042             const char *plugin_name = launch_info.GetProcessPluginName();
3043             CreateProcess(launch_info.GetListenerForProcess(debugger), plugin_name, nullptr);
3044         }
3045
3046         // Since we didn't have a platform launch the process, launch it here.
3047         if (m_process_sp)
3048             error = m_process_sp->Launch (launch_info);
3049     }
3050
3051     if (!m_process_sp)
3052     {
3053         if (error.Success())
3054             error.SetErrorString("failed to launch or debug process");
3055         return error;
3056     }
3057
3058     if (error.Success())
3059     {
3060         if (synchronous_execution || !launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
3061         {
3062             ListenerSP hijack_listener_sp (launch_info.GetHijackListener());
3063             if (!hijack_listener_sp)
3064             {
3065                 hijack_listener_sp.reset(new Listener("lldb.Target.Launch.hijack"));
3066                 launch_info.SetHijackListener(hijack_listener_sp);
3067                 m_process_sp->HijackProcessEvents(hijack_listener_sp.get());
3068             }
3069
3070             StateType state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, false, hijack_listener_sp.get(), nullptr);
3071
3072             if (state == eStateStopped)
3073             {
3074                 if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
3075                 {
3076                     if (synchronous_execution)
3077                     {
3078                         error = m_process_sp->PrivateResume();
3079                         if (error.Success())
3080                         {
3081                             state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, true, hijack_listener_sp.get(), stream);
3082                             const bool must_be_alive = false; // eStateExited is ok, so this must be false
3083                             if (!StateIsStoppedState(state, must_be_alive))
3084                             {
3085                                 error.SetErrorStringWithFormat("process isn't stopped: %s", StateAsCString(state));
3086                             }
3087                         }
3088                     }
3089                     else
3090                     {
3091                         m_process_sp->RestoreProcessEvents();
3092                         error = m_process_sp->PrivateResume();
3093                     }
3094                     if (!error.Success())
3095                     {
3096                         Error error2;
3097                         error2.SetErrorStringWithFormat("process resume at entry point failed: %s", error.AsCString());
3098                         error = error2;
3099                     }
3100                 }
3101             }
3102             else if (state == eStateExited)
3103             {
3104                 bool with_shell = !!launch_info.GetShell();
3105                 const int exit_status = m_process_sp->GetExitStatus();
3106                 const char *exit_desc = m_process_sp->GetExitDescription();
3107 #define LAUNCH_SHELL_MESSAGE "\n'r' and 'run' are aliases that default to launching through a shell.\nTry launching without going through a shell by using 'process launch'."
3108                 if (exit_desc && exit_desc[0])
3109                 {
3110                     if (with_shell)
3111                         error.SetErrorStringWithFormat ("process exited with status %i (%s)" LAUNCH_SHELL_MESSAGE, exit_status, exit_desc);
3112                     else
3113                         error.SetErrorStringWithFormat ("process exited with status %i (%s)", exit_status, exit_desc);
3114                 }
3115                 else
3116                 {
3117                     if (with_shell)
3118                         error.SetErrorStringWithFormat ("process exited with status %i" LAUNCH_SHELL_MESSAGE, exit_status);
3119                     else
3120                         error.SetErrorStringWithFormat ("process exited with status %i", exit_status);
3121                 }
3122             }
3123             else
3124             {
3125                 error.SetErrorStringWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state));
3126             }
3127         }
3128         m_process_sp->RestoreProcessEvents ();
3129     }
3130     else
3131     {
3132         Error error2;
3133         error2.SetErrorStringWithFormat ("process launch failed: %s", error.AsCString());
3134         error = error2;
3135     }
3136     return error;
3137 }
3138
3139 Error
3140 Target::Attach (ProcessAttachInfo &attach_info, Stream *stream)
3141 {
3142     auto state = eStateInvalid;
3143     auto process_sp = GetProcessSP ();
3144     if (process_sp)
3145     {
3146         state = process_sp->GetState ();
3147         if (process_sp->IsAlive () && state != eStateConnected)
3148         {
3149             if (state == eStateAttaching)
3150                 return Error ("process attach is in progress");
3151             return Error ("a process is already being debugged");
3152         }
3153     }
3154
3155     const ModuleSP old_exec_module_sp = GetExecutableModule ();
3156
3157     // If no process info was specified, then use the target executable
3158     // name as the process to attach to by default
3159     if (!attach_info.ProcessInfoSpecified ())
3160     {
3161         if (old_exec_module_sp)
3162             attach_info.GetExecutableFile ().GetFilename () = old_exec_module_sp->GetPlatformFileSpec ().GetFilename ();
3163
3164         if (!attach_info.ProcessInfoSpecified ())
3165         {
3166             return Error ("no process specified, create a target with a file, or specify the --pid or --name");
3167         }
3168     }
3169
3170     const auto platform_sp = GetDebugger ().GetPlatformList ().GetSelectedPlatform ();
3171     ListenerSP hijack_listener_sp;
3172     const bool async = attach_info.GetAsync();
3173     if (!async)
3174     {
3175         hijack_listener_sp.reset (new Listener ("lldb.Target.Attach.attach.hijack"));
3176         attach_info.SetHijackListener (hijack_listener_sp);
3177     }
3178
3179     Error error;
3180     if (state != eStateConnected && platform_sp != nullptr && platform_sp->CanDebugProcess ())
3181     {
3182         SetPlatform (platform_sp);
3183         process_sp = platform_sp->Attach (attach_info, GetDebugger (), this, error);
3184     }
3185     else
3186     {
3187         if (state != eStateConnected)
3188         {
3189             const char *plugin_name = attach_info.GetProcessPluginName ();
3190             process_sp = CreateProcess (attach_info.GetListenerForProcess (GetDebugger ()), plugin_name, nullptr);
3191             if (process_sp == nullptr)
3192             {
3193                 error.SetErrorStringWithFormat ("failed to create process using plugin %s", (plugin_name) ? plugin_name : "null");
3194                 return error;
3195             }
3196         }
3197         if (hijack_listener_sp)
3198             process_sp->HijackProcessEvents (hijack_listener_sp.get ());
3199         error = process_sp->Attach (attach_info);
3200     }
3201
3202     if (error.Success () && process_sp)
3203     {
3204         if (async)
3205         {
3206             process_sp->RestoreProcessEvents ();
3207         }
3208         else
3209         {
3210             state = process_sp->WaitForProcessToStop (nullptr, nullptr, false, attach_info.GetHijackListener ().get (), stream);
3211             process_sp->RestoreProcessEvents ();
3212
3213             if (state != eStateStopped)
3214             {
3215                 const char *exit_desc = process_sp->GetExitDescription ();
3216                 if (exit_desc)
3217                     error.SetErrorStringWithFormat ("%s", exit_desc);
3218                 else
3219                     error.SetErrorString ("process did not stop (no such process or permission problem?)");
3220                 process_sp->Destroy (false);
3221             }
3222         }
3223     }
3224     return error;
3225 }
3226
3227 //--------------------------------------------------------------
3228 // Target::StopHook
3229 //--------------------------------------------------------------
3230 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) :
3231         UserID (uid),
3232         m_target_sp (target_sp),
3233         m_commands (),
3234         m_specifier_sp (),
3235         m_thread_spec_ap(),
3236         m_active (true)
3237 {
3238 }
3239
3240 Target::StopHook::StopHook (const StopHook &rhs) :
3241         UserID (rhs.GetID()),
3242         m_target_sp (rhs.m_target_sp),
3243         m_commands (rhs.m_commands),
3244         m_specifier_sp (rhs.m_specifier_sp),
3245         m_thread_spec_ap (),
3246         m_active (rhs.m_active)
3247 {
3248     if (rhs.m_thread_spec_ap)
3249         m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get()));
3250 }
3251
3252 Target::StopHook::~StopHook() = default;
3253
3254 void
3255 Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier)
3256 {
3257     m_specifier_sp.reset(specifier);
3258 }
3259
3260 void
3261 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier)
3262 {
3263     m_thread_spec_ap.reset (specifier);
3264 }
3265
3266 void
3267 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const
3268 {
3269     int indent_level = s->GetIndentLevel();
3270
3271     s->SetIndentLevel(indent_level + 2);
3272
3273     s->Printf ("Hook: %" PRIu64 "\n", GetID());
3274     if (m_active)
3275         s->Indent ("State: enabled\n");
3276     else
3277         s->Indent ("State: disabled\n");
3278
3279     if (m_specifier_sp)
3280     {
3281         s->Indent();
3282         s->PutCString ("Specifier:\n");
3283         s->SetIndentLevel (indent_level + 4);
3284         m_specifier_sp->GetDescription (s, level);
3285         s->SetIndentLevel (indent_level + 2);
3286     }
3287
3288     if (m_thread_spec_ap)
3289     {
3290         StreamString tmp;
3291         s->Indent("Thread:\n");
3292         m_thread_spec_ap->GetDescription (&tmp, level);
3293         s->SetIndentLevel (indent_level + 4);
3294         s->Indent (tmp.GetData());
3295         s->PutCString ("\n");
3296         s->SetIndentLevel (indent_level + 2);
3297     }
3298
3299     s->Indent ("Commands: \n");
3300     s->SetIndentLevel (indent_level + 4);
3301     uint32_t num_commands = m_commands.GetSize();
3302     for (uint32_t i = 0; i < num_commands; i++)
3303     {
3304         s->Indent(m_commands.GetStringAtIndex(i));
3305         s->PutCString ("\n");
3306     }
3307     s->SetIndentLevel (indent_level);
3308 }
3309
3310 //--------------------------------------------------------------
3311 // class TargetProperties
3312 //--------------------------------------------------------------
3313
3314 OptionEnumValueElement
3315 lldb_private::g_dynamic_value_types[] =
3316 {
3317     { eNoDynamicValues,      "no-dynamic-values", "Don't calculate the dynamic type of values"},
3318     { eDynamicCanRunTarget,  "run-target",        "Calculate the dynamic type of values even if you have to run the target."},
3319     { eDynamicDontRunTarget, "no-run-target",     "Calculate the dynamic type of values, but don't run the target."},
3320     { 0, nullptr, nullptr }
3321 };
3322
3323 static OptionEnumValueElement
3324 g_inline_breakpoint_enums[] =
3325 {
3326     { 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."},
3327     { eInlineBreakpointsHeaders, "headers",   "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."},
3328     { eInlineBreakpointsAlways,  "always",    "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."},
3329     { 0, nullptr, nullptr }
3330 };
3331
3332 typedef enum x86DisassemblyFlavor
3333 {
3334     eX86DisFlavorDefault,
3335     eX86DisFlavorIntel,
3336     eX86DisFlavorATT
3337 } x86DisassemblyFlavor;
3338
3339 static OptionEnumValueElement
3340 g_x86_dis_flavor_value_types[] =
3341 {
3342     { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."},
3343     { eX86DisFlavorIntel,   "intel",   "Intel disassembler flavor."},
3344     { eX86DisFlavorATT,     "att",     "AT&T disassembler flavor."},
3345     { 0, nullptr, nullptr }
3346 };
3347
3348 static OptionEnumValueElement
3349 g_hex_immediate_style_values[] =
3350 {
3351     { Disassembler::eHexStyleC,        "c",      "C-style (0xffff)."},
3352     { Disassembler::eHexStyleAsm,      "asm",    "Asm-style (0ffffh)."},
3353     { 0, nullptr, nullptr }
3354 };
3355
3356 static OptionEnumValueElement
3357 g_load_script_from_sym_file_values[] =
3358 {
3359     { eLoadScriptFromSymFileTrue,    "true",    "Load debug scripts inside symbol files"},
3360     { eLoadScriptFromSymFileFalse,   "false",   "Do not load debug scripts inside symbol files."},
3361     { eLoadScriptFromSymFileWarn,    "warn",    "Warn about debug scripts inside symbol files but do not load them."},
3362     { 0, nullptr, nullptr }
3363 };
3364
3365 static OptionEnumValueElement
3366 g_memory_module_load_level_values[] =
3367 {
3368     { eMemoryModuleLoadLevelMinimal,  "minimal" , "Load minimal information when loading modules from memory. Currently this setting loads sections only."},
3369     { eMemoryModuleLoadLevelPartial,  "partial" , "Load partial information when loading modules from memory. Currently this setting loads sections and function bounds."},
3370     { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."},
3371     { 0, nullptr, nullptr }
3372 };
3373
3374 static PropertyDefinition
3375 g_properties[] =
3376 {
3377     { "default-arch"                       , OptionValue::eTypeArch      , true , 0                         , nullptr, nullptr, "Default architecture to choose, when there's a choice." },
3378     { "move-to-nearest-code"               , OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "Move breakpoints to nearest code." },
3379     { "language"                           , OptionValue::eTypeLanguage  , false, eLanguageTypeUnknown      , nullptr, nullptr, "The language to use when interpreting expressions entered in commands." },
3380     { "expr-prefix"                        , OptionValue::eTypeFileSpec  , false, 0                         , nullptr, nullptr, "Path to a file containing expressions to be prepended to all expressions." },
3381     { "prefer-dynamic-value"               , OptionValue::eTypeEnum      , false, eDynamicDontRunTarget     , nullptr, g_dynamic_value_types, "Should printed values be shown as their dynamic value." },
3382     { "enable-synthetic-value"             , OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "Should synthetic values be used by default whenever available." },
3383     { "skip-prologue"                      , OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "Skip function prologues when setting breakpoints by name." },
3384     { "source-map"                         , OptionValue::eTypePathMap   , false, 0                         , nullptr, nullptr, "Source path remappings are used to track the change of location between a source file when built, and "
3385       "where it exists on the current system.  It consists of an array of duples, the first element of each duple is "
3386       "some part (starting at the root) of the path to the file when it was built, "
3387       "and the second is where the remainder of the original build hierarchy is rooted on the local system.  "
3388       "Each element of the array is checked in order and the first one that results in a match wins." },
3389     { "exec-search-paths"                  , OptionValue::eTypeFileSpecList, false, 0                       , nullptr, nullptr, "Executable search paths to use when locating executable files whose paths don't match the local file system." },
3390     { "debug-file-search-paths"            , OptionValue::eTypeFileSpecList, false, 0                       , nullptr, nullptr, "List of directories to be searched when locating debug symbol files." },
3391     { "clang-module-search-paths"          , OptionValue::eTypeFileSpecList, false, 0                       , nullptr, nullptr, "List of directories to be searched when locating modules for Clang." },
3392     { "auto-import-clang-modules"          , OptionValue::eTypeBoolean   , false, false                     , nullptr, nullptr, "Automatically load Clang modules referred to by the program." },
3393     { "max-children-count"                 , OptionValue::eTypeSInt64    , false, 256                       , nullptr, nullptr, "Maximum number of children to expand in any level of depth." },
3394     { "max-string-summary-length"          , OptionValue::eTypeSInt64    , false, 1024                      , nullptr, nullptr, "Maximum number of characters to show when using %s in summary strings." },
3395     { "max-memory-read-size"               , OptionValue::eTypeSInt64    , false, 1024                      , nullptr, nullptr, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." },
3396     { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "Consult the platform module avoid list when setting non-module specific breakpoints." },
3397     { "arg0"                               , OptionValue::eTypeString    , false, 0                         , nullptr, nullptr, "The first argument passed to the program in the argument array which can be different from the executable itself." },
3398     { "run-args"                           , OptionValue::eTypeArgs      , false, 0                         , nullptr, nullptr, "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." },
3399     { "env-vars"                           , OptionValue::eTypeDictionary, false, OptionValue::eTypeString  , nullptr, nullptr, "A list of all the environment variables to be passed to the executable's environment, and their values." },
3400     { "inherit-env"                        , OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "Inherit the environment from the process that is running LLDB." },
3401     { "input-path"                         , OptionValue::eTypeFileSpec  , false, 0                         , nullptr, nullptr, "The file/path to be used by the executable program for reading its standard input." },
3402     { "output-path"                        , OptionValue::eTypeFileSpec  , false, 0                         , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard output." },
3403     { "error-path"                         , OptionValue::eTypeFileSpec  , false, 0                         , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard error." },
3404     { "detach-on-error"                    , OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "debugserver will detach (rather than killing) a process if it loses connection with lldb." },
3405     { "disable-aslr"                       , OptionValue::eTypeBoolean   , false, true                      , nullptr, nullptr, "Disable Address Space Layout Randomization (ASLR)" },
3406     { "disable-stdio"                      , OptionValue::eTypeBoolean   , false, false                     , nullptr, nullptr, "Disable stdin/stdout for process (e.g. for a GUI application)" },
3407     { "inline-breakpoint-strategy"         , OptionValue::eTypeEnum      , false, eInlineBreakpointsAlways  , nullptr, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. "
3408         "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. "
3409         "Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. "
3410         "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. "
3411         "Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers "
3412         "and find that setting breakpoints is slow, then you can change this setting to headers. "
3413         "This setting allows you to control exactly which strategy is used when setting "
3414         "file and line breakpoints." },
3415     // 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.
3416     { "x86-disassembly-flavor"             , OptionValue::eTypeEnum      , false, eX86DisFlavorDefault,       nullptr, g_x86_dis_flavor_value_types, "The default disassembly flavor to use for x86 or x86-64 targets." },
3417     { "use-hex-immediates"                 , OptionValue::eTypeBoolean   , false, true,                       nullptr, nullptr, "Show immediates in disassembly as hexadecimal." },
3418     { "hex-immediate-style"                , OptionValue::eTypeEnum   ,    false, Disassembler::eHexStyleC,   nullptr, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." },
3419     { "use-fast-stepping"                  , OptionValue::eTypeBoolean   , false, true,                       nullptr, nullptr, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping." },
3420     { "load-script-from-symbol-file"       , OptionValue::eTypeEnum   ,    false, eLoadScriptFromSymFileWarn, nullptr, g_load_script_from_sym_file_values, "Allow LLDB to load scripting resources embedded in symbol files when available." },
3421     { "memory-module-load-level"           , OptionValue::eTypeEnum   ,    false, eMemoryModuleLoadLevelComplete, nullptr, g_memory_module_load_level_values,
3422         "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. "
3423         "This setting helps users control how much information gets loaded when loading modules from memory."
3424         "'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). "
3425         "'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). "
3426         "'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). " },
3427     { "display-expression-in-crashlogs"    , OptionValue::eTypeBoolean   , false, false,                      nullptr, nullptr, "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." },
3428     { "trap-handler-names"                 , OptionValue::eTypeArray     , true,  OptionValue::eTypeString,   nullptr, nullptr, "A list of trap handler function names, e.g. a common Unix user process one is _sigtramp." },
3429     { "display-runtime-support-values"     , OptionValue::eTypeBoolean   , false, false,                      nullptr, nullptr, "If true, LLDB will show variables that are meant to support the operation of a language's runtime support." },
3430     { "non-stop-mode"                      , OptionValue::eTypeBoolean   , false, 0,                          nullptr, nullptr, "Disable lock-step debugging, instead control threads independently." },
3431     { nullptr                                 , OptionValue::eTypeInvalid   , false, 0                         , nullptr, nullptr, nullptr }
3432 };
3433
3434 enum
3435 {
3436     ePropertyDefaultArch,
3437     ePropertyMoveToNearestCode,
3438     ePropertyLanguage,
3439     ePropertyExprPrefix,
3440     ePropertyPreferDynamic,
3441     ePropertyEnableSynthetic,
3442     ePropertySkipPrologue,
3443     ePropertySourceMap,
3444     ePropertyExecutableSearchPaths,
3445     ePropertyDebugFileSearchPaths,
3446     ePropertyClangModuleSearchPaths,
3447     ePropertyAutoImportClangModules,
3448     ePropertyMaxChildrenCount,
3449     ePropertyMaxSummaryLength,
3450     ePropertyMaxMemReadSize,
3451     ePropertyBreakpointUseAvoidList,
3452     ePropertyArg0,
3453     ePropertyRunArgs,
3454     ePropertyEnvVars,
3455     ePropertyInheritEnv,
3456     ePropertyInputPath,
3457     ePropertyOutputPath,
3458     ePropertyErrorPath,
3459     ePropertyDetachOnError,
3460     ePropertyDisableASLR,
3461     ePropertyDisableSTDIO,
3462     ePropertyInlineStrategy,
3463     ePropertyDisassemblyFlavor,
3464     ePropertyUseHexImmediates,
3465     ePropertyHexImmediateStyle,
3466     ePropertyUseFastStepping,
3467     ePropertyLoadScriptFromSymbolFile,
3468     ePropertyMemoryModuleLoadLevel,
3469     ePropertyDisplayExpressionsInCrashlogs,
3470     ePropertyTrapHandlerNames,
3471     ePropertyDisplayRuntimeSupportValues,
3472     ePropertyNonStopModeEnabled
3473 };
3474
3475 class TargetOptionValueProperties : public OptionValueProperties
3476 {
3477 public:
3478     TargetOptionValueProperties (const ConstString &name) :
3479         OptionValueProperties (name),
3480         m_target(nullptr),
3481         m_got_host_env (false)
3482     {
3483     }
3484
3485     // This constructor is used when creating TargetOptionValueProperties when it
3486     // is part of a new lldb_private::Target instance. It will copy all current
3487     // global property values as needed
3488     TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) :
3489         OptionValueProperties(*target_properties_sp->GetValueProperties()),
3490         m_target (target),
3491         m_got_host_env (false)
3492     {
3493     }
3494
3495     const Property *
3496     GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
3497     {
3498         // When getting the value for a key from the target options, we will always
3499         // try and grab the setting from the current target if there is one. Else we just
3500         // use the one from this instance.
3501         if (idx == ePropertyEnvVars)
3502             GetHostEnvironmentIfNeeded ();
3503
3504         if (exe_ctx)
3505         {
3506             Target *target = exe_ctx->GetTargetPtr();
3507             if (target)
3508             {
3509                 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get());
3510                 if (this != target_properties)
3511                     return target_properties->ProtectedGetPropertyAtIndex (idx);
3512             }
3513         }
3514         return ProtectedGetPropertyAtIndex (idx);
3515     }
3516
3517     lldb::TargetSP
3518     GetTargetSP ()
3519     {
3520         return m_target->shared_from_this();
3521     }
3522
3523 protected:
3524     void
3525     GetHostEnvironmentIfNeeded () const
3526     {
3527         if (!m_got_host_env)
3528         {
3529             if (m_target)
3530             {
3531                 m_got_host_env = true;
3532                 const uint32_t idx = ePropertyInheritEnv;
3533                 if (GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0))
3534                 {
3535                     PlatformSP platform_sp (m_target->GetPlatform());
3536                     if (platform_sp)
3537                     {
3538                         StringList env;
3539                         if (platform_sp->GetEnvironment(env))
3540                         {
3541                             OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary(nullptr, ePropertyEnvVars);
3542                             if (env_dict)
3543                             {
3544                                 const bool can_replace = false;
3545                                 const size_t envc = env.GetSize();
3546                                 for (size_t idx=0; idx<envc; idx++)
3547                                 {
3548                                     const char *env_entry = env.GetStringAtIndex (idx);
3549                                     if (env_entry)
3550                                     {
3551                                         const char *equal_pos = ::strchr(env_entry, '=');
3552                                         ConstString key;
3553                                         // It is ok to have environment variables with no values
3554                                         const char *value = nullptr;
3555                                         if (equal_pos)
3556                                         {
3557                                             key.SetCStringWithLength(env_entry, equal_pos - env_entry);
3558                                             if (equal_pos[1])
3559                                                 value = equal_pos + 1;
3560                                         }
3561                                         else
3562                                         {
3563                                             key.SetCString(env_entry);
3564                                         }
3565                                         // Don't allow existing keys to be replaced with ones we get from the platform environment
3566                                         env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace);
3567                                     }
3568                                 }
3569                             }
3570                         }
3571                     }
3572                 }
3573             }
3574         }
3575     }
3576     Target *m_target;
3577     mutable bool m_got_host_env;
3578 };
3579
3580 //----------------------------------------------------------------------
3581 // TargetProperties
3582 //----------------------------------------------------------------------
3583 TargetProperties::TargetProperties (Target *target) :
3584     Properties (),
3585     m_launch_info ()
3586 {
3587     if (target)
3588     {
3589         m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
3590
3591         // Set callbacks to update launch_info whenever "settins set" updated any of these properties
3592         m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
3593         m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this);
3594         m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this);
3595         m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this);
3596         m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this);
3597         m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this);
3598         m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this);
3599         m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this);
3600         m_collection_sp->SetValueChangedCallback(ePropertyDisableSTDIO, TargetProperties::DisableSTDIOValueChangedCallback, this);
3601
3602         // Update m_launch_info once it was created
3603         Arg0ValueChangedCallback(this, nullptr);
3604         RunArgsValueChangedCallback(this, nullptr);
3605         //EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause segfault in Target::GetPlatform()
3606         InputPathValueChangedCallback(this, nullptr);
3607         OutputPathValueChangedCallback(this, nullptr);
3608         ErrorPathValueChangedCallback(this, nullptr);
3609         DetachOnErrorValueChangedCallback(this, nullptr);
3610         DisableASLRValueChangedCallback(this, nullptr);
3611         DisableSTDIOValueChangedCallback(this, nullptr);
3612     }
3613     else
3614     {
3615         m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target")));
3616         m_collection_sp->Initialize(g_properties);
3617         m_collection_sp->AppendProperty(ConstString("process"),
3618                                         ConstString("Settings specify to processes."),
3619                                         true,
3620                                         Process::GetGlobalProperties()->GetValueProperties());
3621     }
3622 }
3623
3624 TargetProperties::~TargetProperties() = default;
3625
3626 ArchSpec
3627 TargetProperties::GetDefaultArchitecture () const
3628 {
3629     OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch);
3630     if (value)
3631         return value->GetCurrentValue();
3632     return ArchSpec();
3633 }
3634
3635 void
3636 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch)
3637 {
3638     OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch);
3639     if (value)
3640         return value->SetCurrentValue(arch, true);
3641 }
3642
3643 bool
3644 TargetProperties::GetMoveToNearestCode() const
3645 {
3646     const uint32_t idx = ePropertyMoveToNearestCode;
3647     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3648 }
3649
3650 lldb::DynamicValueType
3651 TargetProperties::GetPreferDynamicValue() const
3652 {
3653     const uint32_t idx = ePropertyPreferDynamic;
3654     return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3655 }
3656
3657 bool
3658 TargetProperties::SetPreferDynamicValue (lldb::DynamicValueType d)
3659 {
3660     const uint32_t idx = ePropertyPreferDynamic;
3661     return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, d);
3662 }
3663
3664 bool
3665 TargetProperties::GetDisableASLR () const
3666 {
3667     const uint32_t idx = ePropertyDisableASLR;
3668     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3669 }
3670
3671 void
3672 TargetProperties::SetDisableASLR (bool b)
3673 {
3674     const uint32_t idx = ePropertyDisableASLR;
3675     m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3676 }
3677
3678 bool
3679 TargetProperties::GetDetachOnError () const
3680 {
3681     const uint32_t idx = ePropertyDetachOnError;
3682     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3683 }
3684
3685 void
3686 TargetProperties::SetDetachOnError (bool b)
3687 {
3688     const uint32_t idx = ePropertyDetachOnError;
3689     m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3690 }
3691
3692 bool
3693 TargetProperties::GetDisableSTDIO () const
3694 {
3695     const uint32_t idx = ePropertyDisableSTDIO;
3696     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3697 }
3698
3699 void
3700 TargetProperties::SetDisableSTDIO (bool b)
3701 {
3702     const uint32_t idx = ePropertyDisableSTDIO;
3703     m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3704 }
3705
3706 const char *
3707 TargetProperties::GetDisassemblyFlavor () const
3708 {
3709     const uint32_t idx = ePropertyDisassemblyFlavor;
3710     const char *return_value;
3711
3712     x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3713     return_value = g_x86_dis_flavor_value_types[flavor_value].string_value;
3714     return return_value;
3715 }
3716
3717 InlineStrategy
3718 TargetProperties::GetInlineStrategy () const
3719 {
3720     const uint32_t idx = ePropertyInlineStrategy;
3721     return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3722 }
3723
3724 const char *
3725 TargetProperties::GetArg0 () const
3726 {
3727     const uint32_t idx = ePropertyArg0;
3728     return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, nullptr);
3729 }
3730
3731 void
3732 TargetProperties::SetArg0 (const char *arg)
3733 {
3734     const uint32_t idx = ePropertyArg0;
3735     m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, arg);
3736     m_launch_info.SetArg0(arg);
3737 }
3738
3739 bool
3740 TargetProperties::GetRunArguments (Args &args) const
3741 {
3742     const uint32_t idx = ePropertyRunArgs;
3743     return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
3744 }
3745
3746 void
3747 TargetProperties::SetRunArguments (const Args &args)
3748 {
3749     const uint32_t idx = ePropertyRunArgs;
3750     m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
3751     m_launch_info.GetArguments() = args;
3752 }
3753
3754 size_t
3755 TargetProperties::GetEnvironmentAsArgs (Args &env) const
3756 {
3757     const uint32_t idx = ePropertyEnvVars;
3758     return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env);
3759 }
3760
3761 void
3762 TargetProperties::SetEnvironmentFromArgs (const Args &env)
3763 {
3764     const uint32_t idx = ePropertyEnvVars;
3765     m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, env);
3766     m_launch_info.GetEnvironmentEntries() = env;
3767 }
3768
3769 bool
3770 TargetProperties::GetSkipPrologue() const
3771 {
3772     const uint32_t idx = ePropertySkipPrologue;
3773     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3774 }
3775
3776 PathMappingList &
3777 TargetProperties::GetSourcePathMap () const
3778 {
3779     const uint32_t idx = ePropertySourceMap;
3780     OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings(nullptr, false, idx);
3781     assert(option_value);
3782     return option_value->GetCurrentValue();
3783 }
3784
3785 FileSpecList &
3786 TargetProperties::GetExecutableSearchPaths ()
3787 {
3788     const uint32_t idx = ePropertyExecutableSearchPaths;
3789     OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx);
3790     assert(option_value);
3791     return option_value->GetCurrentValue();
3792 }
3793
3794 FileSpecList &
3795 TargetProperties::GetDebugFileSearchPaths ()
3796 {
3797     const uint32_t idx = ePropertyDebugFileSearchPaths;
3798     OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx);
3799     assert(option_value);
3800     return option_value->GetCurrentValue();
3801 }
3802
3803 FileSpecList &
3804 TargetProperties::GetClangModuleSearchPaths ()
3805 {
3806     const uint32_t idx = ePropertyClangModuleSearchPaths;
3807     OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx);
3808     assert(option_value);
3809     return option_value->GetCurrentValue();
3810 }
3811
3812 bool
3813 TargetProperties::GetEnableAutoImportClangModules() const
3814 {
3815     const uint32_t idx = ePropertyAutoImportClangModules;
3816     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3817 }
3818
3819 bool
3820 TargetProperties::GetEnableSyntheticValue () const
3821 {
3822     const uint32_t idx = ePropertyEnableSynthetic;
3823     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3824 }
3825
3826 uint32_t
3827 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const
3828 {
3829     const uint32_t idx = ePropertyMaxChildrenCount;
3830     return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
3831 }
3832
3833 uint32_t
3834 TargetProperties::GetMaximumSizeOfStringSummary() const
3835 {
3836     const uint32_t idx = ePropertyMaxSummaryLength;
3837     return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
3838 }
3839
3840 uint32_t
3841 TargetProperties::GetMaximumMemReadSize () const
3842 {
3843     const uint32_t idx = ePropertyMaxMemReadSize;
3844     return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
3845 }
3846
3847 FileSpec
3848 TargetProperties::GetStandardInputPath () const
3849 {
3850     const uint32_t idx = ePropertyInputPath;
3851     return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3852 }
3853
3854 void
3855 TargetProperties::SetStandardInputPath (const char *p)
3856 {
3857     const uint32_t idx = ePropertyInputPath;
3858     m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
3859 }
3860
3861 FileSpec
3862 TargetProperties::GetStandardOutputPath () const
3863 {
3864     const uint32_t idx = ePropertyOutputPath;
3865     return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3866 }
3867
3868 void
3869 TargetProperties::SetStandardOutputPath (const char *p)
3870 {
3871     const uint32_t idx = ePropertyOutputPath;
3872     m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
3873 }
3874
3875 FileSpec
3876 TargetProperties::GetStandardErrorPath () const
3877 {
3878     const uint32_t idx = ePropertyErrorPath;
3879     return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3880 }
3881
3882 LanguageType
3883 TargetProperties::GetLanguage () const
3884 {
3885     OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(nullptr, ePropertyLanguage);
3886     if (value)
3887         return value->GetCurrentValue();
3888     return LanguageType();
3889 }
3890
3891 const char *
3892 TargetProperties::GetExpressionPrefixContentsAsCString ()
3893 {
3894     const uint32_t idx = ePropertyExprPrefix;
3895     OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false, idx);
3896     if (file)
3897     {
3898         const bool null_terminate = true;
3899         DataBufferSP data_sp(file->GetFileContents(null_terminate));
3900         if (data_sp)
3901             return (const char *) data_sp->GetBytes();
3902     }
3903     return nullptr;
3904 }
3905
3906 void
3907 TargetProperties::SetStandardErrorPath (const char *p)
3908 {
3909     const uint32_t idx = ePropertyErrorPath;
3910     m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
3911 }
3912
3913 bool
3914 TargetProperties::GetBreakpointsConsultPlatformAvoidList ()
3915 {
3916     const uint32_t idx = ePropertyBreakpointUseAvoidList;
3917     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3918 }
3919
3920 bool
3921 TargetProperties::GetUseHexImmediates () const
3922 {
3923     const uint32_t idx = ePropertyUseHexImmediates;
3924     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3925 }
3926
3927 bool
3928 TargetProperties::GetUseFastStepping () const
3929 {
3930     const uint32_t idx = ePropertyUseFastStepping;
3931     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3932 }
3933
3934 bool
3935 TargetProperties::GetDisplayExpressionsInCrashlogs () const
3936 {
3937     const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs;
3938     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3939 }
3940
3941 LoadScriptFromSymFile
3942 TargetProperties::GetLoadScriptFromSymbolFile () const
3943 {
3944     const uint32_t idx = ePropertyLoadScriptFromSymbolFile;
3945     return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3946 }
3947
3948 Disassembler::HexImmediateStyle
3949 TargetProperties::GetHexImmediateStyle () const
3950 {
3951     const uint32_t idx = ePropertyHexImmediateStyle;
3952     return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3953 }
3954
3955 MemoryModuleLoadLevel
3956 TargetProperties::GetMemoryModuleLoadLevel() const
3957 {
3958     const uint32_t idx = ePropertyMemoryModuleLoadLevel;
3959     return (MemoryModuleLoadLevel)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3960 }
3961
3962 bool
3963 TargetProperties::GetUserSpecifiedTrapHandlerNames (Args &args) const
3964 {
3965     const uint32_t idx = ePropertyTrapHandlerNames;
3966     return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
3967 }
3968
3969 void
3970 TargetProperties::SetUserSpecifiedTrapHandlerNames (const Args &args)
3971 {
3972     const uint32_t idx = ePropertyTrapHandlerNames;
3973     m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
3974 }
3975
3976 bool
3977 TargetProperties::GetDisplayRuntimeSupportValues () const
3978 {
3979     const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
3980     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
3981 }
3982
3983 void
3984 TargetProperties::SetDisplayRuntimeSupportValues (bool b)
3985 {
3986     const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
3987     m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3988 }
3989
3990 bool
3991 TargetProperties::GetNonStopModeEnabled () const
3992 {
3993     const uint32_t idx = ePropertyNonStopModeEnabled;
3994     return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
3995 }
3996
3997 void
3998 TargetProperties::SetNonStopModeEnabled (bool b)
3999 {
4000     const uint32_t idx = ePropertyNonStopModeEnabled;
4001     m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
4002 }
4003
4004 const ProcessLaunchInfo &
4005 TargetProperties::GetProcessLaunchInfo ()
4006 {
4007     m_launch_info.SetArg0(GetArg0()); // FIXME: Arg0 callback doesn't work
4008     return m_launch_info;
4009 }
4010
4011 void
4012 TargetProperties::SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
4013 {
4014     m_launch_info = launch_info;
4015     SetArg0(launch_info.GetArg0());
4016     SetRunArguments(launch_info.GetArguments());
4017     SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries());
4018     const FileAction *input_file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
4019     if (input_file_action)
4020     {
4021         const char *input_path = input_file_action->GetPath();
4022         if (input_path)
4023             SetStandardInputPath(input_path);
4024     }
4025     const FileAction *output_file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
4026     if (output_file_action)
4027     {
4028         const char *output_path = output_file_action->GetPath();
4029         if (output_path)
4030             SetStandardOutputPath(output_path);
4031     }
4032     const FileAction *error_file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
4033     if (error_file_action)
4034     {
4035         const char *error_path = error_file_action->GetPath();
4036         if (error_path)
4037             SetStandardErrorPath(error_path);
4038     }
4039     SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError));
4040     SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR));
4041     SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO));
4042 }
4043
4044 void
4045 TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *)
4046 {
4047     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4048     this_->m_launch_info.SetArg0(this_->GetArg0());
4049 }
4050
4051 void
4052 TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *)
4053 {
4054     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4055     Args args;
4056     if (this_->GetRunArguments(args))
4057         this_->m_launch_info.GetArguments() = args;
4058 }
4059
4060 void
4061 TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *)
4062 {
4063     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4064     Args args;
4065     if (this_->GetEnvironmentAsArgs(args))
4066         this_->m_launch_info.GetEnvironmentEntries() = args;
4067 }
4068
4069 void
4070 TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
4071 {
4072     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4073     this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath(), true, false);
4074 }
4075
4076 void
4077 TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
4078 {
4079     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4080     this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath(), false, true);
4081 }
4082
4083 void
4084 TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *)
4085 {
4086     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4087     this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath(), false, true);
4088 }
4089
4090 void
4091 TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *)
4092 {
4093     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4094     if (this_->GetDetachOnError())
4095         this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError);
4096     else
4097         this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError);
4098 }
4099
4100 void
4101 TargetProperties::DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *)
4102 {
4103     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4104     if (this_->GetDisableASLR())
4105         this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR);
4106     else
4107         this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR);
4108 }
4109
4110 void
4111 TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *)
4112 {
4113     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4114     if (this_->GetDisableSTDIO())
4115         this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO);
4116     else
4117         this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO);
4118 }
4119
4120 //----------------------------------------------------------------------
4121 // Target::TargetEventData
4122 //----------------------------------------------------------------------
4123
4124 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp) :
4125     EventData (),
4126     m_target_sp (target_sp),
4127     m_module_list ()
4128 {
4129 }
4130
4131 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list) :
4132     EventData (),
4133     m_target_sp (target_sp),
4134     m_module_list (module_list)
4135 {
4136 }
4137
4138 Target::TargetEventData::~TargetEventData() = default;
4139
4140 const ConstString &
4141 Target::TargetEventData::GetFlavorString ()
4142 {
4143     static ConstString g_flavor ("Target::TargetEventData");
4144     return g_flavor;
4145 }
4146
4147 void
4148 Target::TargetEventData::Dump (Stream *s) const
4149 {
4150 }
4151
4152 const Target::TargetEventData *
4153 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr)
4154 {
4155     if (event_ptr)
4156     {
4157         const EventData *event_data = event_ptr->GetData();
4158         if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString())
4159             return static_cast <const TargetEventData *> (event_ptr->GetData());
4160     }
4161     return nullptr;
4162 }
4163
4164 TargetSP
4165 Target::TargetEventData::GetTargetFromEvent (const Event *event_ptr)
4166 {
4167     TargetSP target_sp;
4168     const TargetEventData *event_data = GetEventDataFromEvent (event_ptr);
4169     if (event_data)
4170         target_sp = event_data->m_target_sp;
4171     return target_sp;
4172 }
4173
4174 ModuleList
4175 Target::TargetEventData::GetModuleListFromEvent (const Event *event_ptr)
4176 {
4177     ModuleList module_list;
4178     const TargetEventData *event_data = GetEventDataFromEvent (event_ptr);
4179     if (event_data)
4180         module_list = event_data->m_module_list;
4181     return module_list;
4182 }