contrib/llvm/tools/lldb/source/Commands/CommandObjectTarget.cpp

   1 //===-- CommandObjectTarget.cpp ---------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "CommandObjectTarget.h"
  11
  12 // Project includes
  13 #include "lldb/Core/Debugger.h"
  14 #include "lldb/Core/IOHandler.h"
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Core/ModuleSpec.h"
  17 #include "lldb/Core/Section.h"
  18 #include "lldb/Core/State.h"
  19 #include "lldb/Core/ValueObjectVariable.h"
  20 #include "lldb/DataFormatters/ValueObjectPrinter.h"
  21 #include "lldb/Host/OptionParser.h"
  22 #include "lldb/Host/StringConvert.h"
  23 #include "lldb/Host/Symbols.h"
  24 #include "lldb/Interpreter/Args.h"
  25 #include "lldb/Interpreter/CommandInterpreter.h"
  26 #include "lldb/Interpreter/CommandReturnObject.h"
  27 #include "lldb/Interpreter/OptionGroupArchitecture.h"
  28 #include "lldb/Interpreter/OptionGroupBoolean.h"
  29 #include "lldb/Interpreter/OptionGroupFile.h"
  30 #include "lldb/Interpreter/OptionGroupFormat.h"
  31 #include "lldb/Interpreter/OptionGroupPlatform.h"
  32 #include "lldb/Interpreter/OptionGroupString.h"
  33 #include "lldb/Interpreter/OptionGroupUInt64.h"
  34 #include "lldb/Interpreter/OptionGroupUUID.h"
  35 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
  36 #include "lldb/Interpreter/OptionGroupVariable.h"
  37 #include "lldb/Interpreter/Options.h"
  38 #include "lldb/Symbol/CompileUnit.h"
  39 #include "lldb/Symbol/FuncUnwinders.h"
  40 #include "lldb/Symbol/LineTable.h"
  41 #include "lldb/Symbol/ObjectFile.h"
  42 #include "lldb/Symbol/SymbolFile.h"
  43 #include "lldb/Symbol/SymbolVendor.h"
  44 #include "lldb/Symbol/UnwindPlan.h"
  45 #include "lldb/Symbol/VariableList.h"
  46 #include "lldb/Target/ABI.h"
  47 #include "lldb/Target/Process.h"
  48 #include "lldb/Target/SectionLoadList.h"
  49 #include "lldb/Target/StackFrame.h"
  50 #include "lldb/Target/Thread.h"
  51 #include "lldb/Target/ThreadSpec.h"
  52 #include "lldb/Utility/Timer.h"
  53
  54 #include "llvm/Support/FileSystem.h"
  55 #include "llvm/Support/FormatAdapters.h"
  56
  57 // C Includes
  58 // C++ Includes
  59 #include <cerrno>
  60
  61 using namespace lldb;
  62 using namespace lldb_private;
  63
  64 static void DumpTargetInfo(uint32_t target_idx, Target *target,
  65                            const char *prefix_cstr,
  66                            bool show_stopped_process_status, Stream &strm) {
  67   const ArchSpec &target_arch = target->GetArchitecture();
  68
  69   Module *exe_module = target->GetExecutableModulePointer();
  70   char exe_path[PATH_MAX];
  71   bool exe_valid = false;
  72   if (exe_module)
  73     exe_valid = exe_module->GetFileSpec().GetPath(exe_path, sizeof(exe_path));
  74
  75   if (!exe_valid)
  76     ::strcpy(exe_path, "<none>");
  77
  78   strm.Printf("%starget #%u: %s", prefix_cstr ? prefix_cstr : "", target_idx,
  79               exe_path);
  80
  81   uint32_t properties = 0;
  82   if (target_arch.IsValid()) {
  83     strm.Printf("%sarch=", properties++ > 0 ? ", " : " ( ");
  84     target_arch.DumpTriple(strm);
  85     properties++;
  86   }
  87   PlatformSP platform_sp(target->GetPlatform());
  88   if (platform_sp)
  89     strm.Printf("%splatform=%s", properties++ > 0 ? ", " : " ( ",
  90                 platform_sp->GetName().GetCString());
  91
  92   ProcessSP process_sp(target->GetProcessSP());
  93   bool show_process_status = false;
  94   if (process_sp) {
  95     lldb::pid_t pid = process_sp->GetID();
  96     StateType state = process_sp->GetState();
  97     if (show_stopped_process_status)
  98       show_process_status = StateIsStoppedState(state, true);
  99     const char *state_cstr = StateAsCString(state);
 100     if (pid != LLDB_INVALID_PROCESS_ID)
 101       strm.Printf("%spid=%" PRIu64, properties++ > 0 ? ", " : " ( ", pid);
 102     strm.Printf("%sstate=%s", properties++ > 0 ? ", " : " ( ", state_cstr);
 103   }
 104   if (properties > 0)
 105     strm.PutCString(" )\n");
 106   else
 107     strm.EOL();
 108   if (show_process_status) {
 109     const bool only_threads_with_stop_reason = true;
 110     const uint32_t start_frame = 0;
 111     const uint32_t num_frames = 1;
 112     const uint32_t num_frames_with_source = 1;
 113     const bool     stop_format = false;
 114     process_sp->GetStatus(strm);
 115     process_sp->GetThreadStatus(strm, only_threads_with_stop_reason,
 116                                 start_frame, num_frames,
 117                                 num_frames_with_source, stop_format);
 118   }
 119 }
 120
 121 static uint32_t DumpTargetList(TargetList &target_list,
 122                                bool show_stopped_process_status, Stream &strm) {
 123   const uint32_t num_targets = target_list.GetNumTargets();
 124   if (num_targets) {
 125     TargetSP selected_target_sp(target_list.GetSelectedTarget());
 126     strm.PutCString("Current targets:\n");
 127     for (uint32_t i = 0; i < num_targets; ++i) {
 128       TargetSP target_sp(target_list.GetTargetAtIndex(i));
 129       if (target_sp) {
 130         bool is_selected = target_sp.get() == selected_target_sp.get();
 131         DumpTargetInfo(i, target_sp.get(), is_selected ? "* " : "  ",
 132                        show_stopped_process_status, strm);
 133       }
 134     }
 135   }
 136   return num_targets;
 137 }
 138
 139 #pragma mark CommandObjectTargetCreate
 140
 141 //-------------------------------------------------------------------------
 142 // "target create"
 143 //-------------------------------------------------------------------------
 144
 145 class CommandObjectTargetCreate : public CommandObjectParsed {
 146 public:
 147   CommandObjectTargetCreate(CommandInterpreter &interpreter)
 148       : CommandObjectParsed(
 149             interpreter, "target create",
 150             "Create a target using the argument as the main executable.",
 151             nullptr),
 152         m_option_group(), m_arch_option(),
 153         m_core_file(LLDB_OPT_SET_1, false, "core", 'c', 0, eArgTypeFilename,
 154                     "Fullpath to a core file to use for this target."),
 155         m_platform_path(LLDB_OPT_SET_1, false, "platform-path", 'P', 0,
 156                         eArgTypePath,
 157                         "Path to the remote file to use for this target."),
 158         m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0,
 159                       eArgTypeFilename, "Fullpath to a stand alone debug "
 160                                         "symbols file for when debug symbols "
 161                                         "are not in the executable."),
 162         m_remote_file(
 163             LLDB_OPT_SET_1, false, "remote-file", 'r', 0, eArgTypeFilename,
 164             "Fullpath to the file on the remote host if debugging remotely."),
 165         m_add_dependents(LLDB_OPT_SET_1, false, "no-dependents", 'd',
 166                          "Don't load dependent files when creating the target, "
 167                          "just add the specified executable.",
 168                          true, true) {
 169     CommandArgumentEntry arg;
 170     CommandArgumentData file_arg;
 171
 172     // Define the first (and only) variant of this arg.
 173     file_arg.arg_type = eArgTypeFilename;
 174     file_arg.arg_repetition = eArgRepeatPlain;
 175
 176     // There is only one variant this argument could be; put it into the
 177     // argument entry.
 178     arg.push_back(file_arg);
 179
 180     // Push the data for the first argument into the m_arguments vector.
 181     m_arguments.push_back(arg);
 182
 183     m_option_group.Append(&m_arch_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 184     m_option_group.Append(&m_core_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 185     m_option_group.Append(&m_platform_path, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 186     m_option_group.Append(&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 187     m_option_group.Append(&m_remote_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 188     m_option_group.Append(&m_add_dependents, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 189     m_option_group.Finalize();
 190   }
 191
 192   ~CommandObjectTargetCreate() override = default;
 193
 194   Options *GetOptions() override { return &m_option_group; }
 195
 196   int HandleArgumentCompletion(Args &input, int &cursor_index,
 197                                int &cursor_char_position,
 198                                OptionElementVector &opt_element_vector,
 199                                int match_start_point, int max_return_elements,
 200                                bool &word_complete,
 201                                StringList &matches) override {
 202     std::string completion_str(input.GetArgumentAtIndex(cursor_index));
 203     completion_str.erase(cursor_char_position);
 204
 205     CommandCompletions::InvokeCommonCompletionCallbacks(
 206         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
 207         completion_str.c_str(), match_start_point, max_return_elements, nullptr,
 208         word_complete, matches);
 209     return matches.GetSize();
 210   }
 211
 212 protected:
 213   bool DoExecute(Args &command, CommandReturnObject &result) override {
 214     const size_t argc = command.GetArgumentCount();
 215     FileSpec core_file(m_core_file.GetOptionValue().GetCurrentValue());
 216     FileSpec remote_file(m_remote_file.GetOptionValue().GetCurrentValue());
 217
 218     if (core_file) {
 219       if (!core_file.Exists()) {
 220         result.AppendErrorWithFormat("core file '%s' doesn't exist",
 221                                      core_file.GetPath().c_str());
 222         result.SetStatus(eReturnStatusFailed);
 223         return false;
 224       }
 225       if (!core_file.Readable()) {
 226         result.AppendErrorWithFormat("core file '%s' is not readable",
 227                                      core_file.GetPath().c_str());
 228         result.SetStatus(eReturnStatusFailed);
 229         return false;
 230       }
 231     }
 232
 233     if (argc == 1 || core_file || remote_file) {
 234       FileSpec symfile(m_symbol_file.GetOptionValue().GetCurrentValue());
 235       if (symfile) {
 236         if (symfile.Exists()) {
 237           if (!symfile.Readable()) {
 238             result.AppendErrorWithFormat("symbol file '%s' is not readable",
 239                                          symfile.GetPath().c_str());
 240             result.SetStatus(eReturnStatusFailed);
 241             return false;
 242           }
 243         } else {
 244           char symfile_path[PATH_MAX];
 245           symfile.GetPath(symfile_path, sizeof(symfile_path));
 246           result.AppendErrorWithFormat("invalid symbol file path '%s'",
 247                                        symfile_path);
 248           result.SetStatus(eReturnStatusFailed);
 249           return false;
 250         }
 251       }
 252
 253       const char *file_path = command.GetArgumentAtIndex(0);
 254       static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
 255       Timer scoped_timer(func_cat, "(lldb) target create '%s'", file_path);
 256       FileSpec file_spec;
 257
 258       if (file_path)
 259         file_spec.SetFile(file_path, true);
 260
 261       bool must_set_platform_path = false;
 262
 263       Debugger &debugger = m_interpreter.GetDebugger();
 264
 265       TargetSP target_sp;
 266       llvm::StringRef arch_cstr = m_arch_option.GetArchitectureName();
 267       const bool get_dependent_files =
 268           m_add_dependents.GetOptionValue().GetCurrentValue();
 269       Status error(debugger.GetTargetList().CreateTarget(
 270           debugger, file_path, arch_cstr, get_dependent_files, nullptr,
 271           target_sp));
 272
 273       if (target_sp) {
 274         // Only get the platform after we create the target because we might
 275         // have
 276         // switched platforms depending on what the arguments were to
 277         // CreateTarget()
 278         // we can't rely on the selected platform.
 279
 280         PlatformSP platform_sp = target_sp->GetPlatform();
 281
 282         if (remote_file) {
 283           if (platform_sp) {
 284             // I have a remote file.. two possible cases
 285             if (file_spec && file_spec.Exists()) {
 286               // if the remote file does not exist, push it there
 287               if (!platform_sp->GetFileExists(remote_file)) {
 288                 Status err = platform_sp->PutFile(file_spec, remote_file);
 289                 if (err.Fail()) {
 290                   result.AppendError(err.AsCString());
 291                   result.SetStatus(eReturnStatusFailed);
 292                   return false;
 293                 }
 294               }
 295             } else {
 296               // there is no local file and we need one
 297               // in order to make the remote ---> local transfer we need a
 298               // platform
 299               // TODO: if the user has passed in a --platform argument, use it
 300               // to fetch the right platform
 301               if (!platform_sp) {
 302                 result.AppendError(
 303                     "unable to perform remote debugging without a platform");
 304                 result.SetStatus(eReturnStatusFailed);
 305                 return false;
 306               }
 307               if (file_path) {
 308                 // copy the remote file to the local file
 309                 Status err = platform_sp->GetFile(remote_file, file_spec);
 310                 if (err.Fail()) {
 311                   result.AppendError(err.AsCString());
 312                   result.SetStatus(eReturnStatusFailed);
 313                   return false;
 314                 }
 315               } else {
 316                 // make up a local file
 317                 result.AppendError("remote --> local transfer without local "
 318                                    "path is not implemented yet");
 319                 result.SetStatus(eReturnStatusFailed);
 320                 return false;
 321               }
 322             }
 323           } else {
 324             result.AppendError("no platform found for target");
 325             result.SetStatus(eReturnStatusFailed);
 326             return false;
 327           }
 328         }
 329
 330         if (symfile || remote_file) {
 331           ModuleSP module_sp(target_sp->GetExecutableModule());
 332           if (module_sp) {
 333             if (symfile)
 334               module_sp->SetSymbolFileFileSpec(symfile);
 335             if (remote_file) {
 336               std::string remote_path = remote_file.GetPath();
 337               target_sp->SetArg0(remote_path.c_str());
 338               module_sp->SetPlatformFileSpec(remote_file);
 339             }
 340           }
 341         }
 342
 343         debugger.GetTargetList().SetSelectedTarget(target_sp.get());
 344         if (must_set_platform_path) {
 345           ModuleSpec main_module_spec(file_spec);
 346           ModuleSP module_sp = target_sp->GetSharedModule(main_module_spec);
 347           if (module_sp)
 348             module_sp->SetPlatformFileSpec(remote_file);
 349         }
 350         if (core_file) {
 351           char core_path[PATH_MAX];
 352           core_file.GetPath(core_path, sizeof(core_path));
 353           if (core_file.Exists()) {
 354             if (!core_file.Readable()) {
 355               result.AppendMessageWithFormat(
 356                   "Core file '%s' is not readable.\n", core_path);
 357               result.SetStatus(eReturnStatusFailed);
 358               return false;
 359             }
 360             FileSpec core_file_dir;
 361             core_file_dir.GetDirectory() = core_file.GetDirectory();
 362             target_sp->GetExecutableSearchPaths().Append(core_file_dir);
 363
 364             ProcessSP process_sp(target_sp->CreateProcess(
 365                 m_interpreter.GetDebugger().GetListener(), llvm::StringRef(),
 366                 &core_file));
 367
 368             if (process_sp) {
 369               // Seems weird that we Launch a core file, but that is
 370               // what we do!
 371               error = process_sp->LoadCore();
 372
 373               if (error.Fail()) {
 374                 result.AppendError(
 375                     error.AsCString("can't find plug-in for core file"));
 376                 result.SetStatus(eReturnStatusFailed);
 377                 return false;
 378               } else {
 379                 result.AppendMessageWithFormat(
 380                     "Core file '%s' (%s) was loaded.\n", core_path,
 381                     target_sp->GetArchitecture().GetArchitectureName());
 382                 result.SetStatus(eReturnStatusSuccessFinishNoResult);
 383               }
 384             } else {
 385               result.AppendErrorWithFormat(
 386                   "Unable to find process plug-in for core file '%s'\n",
 387                   core_path);
 388               result.SetStatus(eReturnStatusFailed);
 389             }
 390           } else {
 391             result.AppendErrorWithFormat("Core file '%s' does not exist\n",
 392                                          core_path);
 393             result.SetStatus(eReturnStatusFailed);
 394           }
 395         } else {
 396           result.AppendMessageWithFormat(
 397               "Current executable set to '%s' (%s).\n", file_path,
 398               target_sp->GetArchitecture().GetArchitectureName());
 399           result.SetStatus(eReturnStatusSuccessFinishNoResult);
 400         }
 401       } else {
 402         result.AppendError(error.AsCString());
 403         result.SetStatus(eReturnStatusFailed);
 404       }
 405     } else {
 406       result.AppendErrorWithFormat("'%s' takes exactly one executable path "
 407                                    "argument, or use the --core option.\n",
 408                                    m_cmd_name.c_str());
 409       result.SetStatus(eReturnStatusFailed);
 410     }
 411     return result.Succeeded();
 412   }
 413
 414 private:
 415   OptionGroupOptions m_option_group;
 416   OptionGroupArchitecture m_arch_option;
 417   OptionGroupFile m_core_file;
 418   OptionGroupFile m_platform_path;
 419   OptionGroupFile m_symbol_file;
 420   OptionGroupFile m_remote_file;
 421   OptionGroupBoolean m_add_dependents;
 422 };
 423
 424 #pragma mark CommandObjectTargetList
 425
 426 //----------------------------------------------------------------------
 427 // "target list"
 428 //----------------------------------------------------------------------
 429
 430 class CommandObjectTargetList : public CommandObjectParsed {
 431 public:
 432   CommandObjectTargetList(CommandInterpreter &interpreter)
 433       : CommandObjectParsed(
 434             interpreter, "target list",
 435             "List all current targets in the current debug session.", nullptr) {
 436   }
 437
 438   ~CommandObjectTargetList() override = default;
 439
 440 protected:
 441   bool DoExecute(Args &args, CommandReturnObject &result) override {
 442     if (args.GetArgumentCount() == 0) {
 443       Stream &strm = result.GetOutputStream();
 444
 445       bool show_stopped_process_status = false;
 446       if (DumpTargetList(m_interpreter.GetDebugger().GetTargetList(),
 447                          show_stopped_process_status, strm) == 0) {
 448         strm.PutCString("No targets.\n");
 449       }
 450       result.SetStatus(eReturnStatusSuccessFinishResult);
 451     } else {
 452       result.AppendError("the 'target list' command takes no arguments\n");
 453       result.SetStatus(eReturnStatusFailed);
 454     }
 455     return result.Succeeded();
 456   }
 457 };
 458
 459 #pragma mark CommandObjectTargetSelect
 460
 461 //----------------------------------------------------------------------
 462 // "target select"
 463 //----------------------------------------------------------------------
 464
 465 class CommandObjectTargetSelect : public CommandObjectParsed {
 466 public:
 467   CommandObjectTargetSelect(CommandInterpreter &interpreter)
 468       : CommandObjectParsed(
 469             interpreter, "target select",
 470             "Select a target as the current target by target index.", nullptr) {
 471   }
 472
 473   ~CommandObjectTargetSelect() override = default;
 474
 475 protected:
 476   bool DoExecute(Args &args, CommandReturnObject &result) override {
 477     if (args.GetArgumentCount() == 1) {
 478       bool success = false;
 479       const char *target_idx_arg = args.GetArgumentAtIndex(0);
 480       uint32_t target_idx =
 481           StringConvert::ToUInt32(target_idx_arg, UINT32_MAX, 0, &success);
 482       if (success) {
 483         TargetList &target_list = m_interpreter.GetDebugger().GetTargetList();
 484         const uint32_t num_targets = target_list.GetNumTargets();
 485         if (target_idx < num_targets) {
 486           TargetSP target_sp(target_list.GetTargetAtIndex(target_idx));
 487           if (target_sp) {
 488             Stream &strm = result.GetOutputStream();
 489             target_list.SetSelectedTarget(target_sp.get());
 490             bool show_stopped_process_status = false;
 491             DumpTargetList(target_list, show_stopped_process_status, strm);
 492             result.SetStatus(eReturnStatusSuccessFinishResult);
 493           } else {
 494             result.AppendErrorWithFormat("target #%u is NULL in target list\n",
 495                                          target_idx);
 496             result.SetStatus(eReturnStatusFailed);
 497           }
 498         } else {
 499           if (num_targets > 0) {
 500             result.AppendErrorWithFormat(
 501                 "index %u is out of range, valid target indexes are 0 - %u\n",
 502                 target_idx, num_targets - 1);
 503           } else {
 504             result.AppendErrorWithFormat(
 505                 "index %u is out of range since there are no active targets\n",
 506                 target_idx);
 507           }
 508           result.SetStatus(eReturnStatusFailed);
 509         }
 510       } else {
 511         result.AppendErrorWithFormat("invalid index string value '%s'\n",
 512                                      target_idx_arg);
 513         result.SetStatus(eReturnStatusFailed);
 514       }
 515     } else {
 516       result.AppendError(
 517           "'target select' takes a single argument: a target index\n");
 518       result.SetStatus(eReturnStatusFailed);
 519     }
 520     return result.Succeeded();
 521   }
 522 };
 523
 524 #pragma mark CommandObjectTargetSelect
 525
 526 //----------------------------------------------------------------------
 527 // "target delete"
 528 //----------------------------------------------------------------------
 529
 530 class CommandObjectTargetDelete : public CommandObjectParsed {
 531 public:
 532   CommandObjectTargetDelete(CommandInterpreter &interpreter)
 533       : CommandObjectParsed(interpreter, "target delete",
 534                             "Delete one or more targets by target index.",
 535                             nullptr),
 536         m_option_group(), m_all_option(LLDB_OPT_SET_1, false, "all", 'a',
 537                                        "Delete all targets.", false, true),
 538         m_cleanup_option(
 539             LLDB_OPT_SET_1, false, "clean", 'c',
 540             "Perform extra cleanup to minimize memory consumption after "
 541             "deleting the target.  "
 542             "By default, LLDB will keep in memory any modules previously "
 543             "loaded by the target as well "
 544             "as all of its debug info.  Specifying --clean will unload all of "
 545             "these shared modules and "
 546             "cause them to be reparsed again the next time the target is run",
 547             false, true) {
 548     m_option_group.Append(&m_all_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 549     m_option_group.Append(&m_cleanup_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 550     m_option_group.Finalize();
 551   }
 552
 553   ~CommandObjectTargetDelete() override = default;
 554
 555   Options *GetOptions() override { return &m_option_group; }
 556
 557 protected:
 558   bool DoExecute(Args &args, CommandReturnObject &result) override {
 559     const size_t argc = args.GetArgumentCount();
 560     std::vector<TargetSP> delete_target_list;
 561     TargetList &target_list = m_interpreter.GetDebugger().GetTargetList();
 562     TargetSP target_sp;
 563
 564     if (m_all_option.GetOptionValue()) {
 565       for (int i = 0; i < target_list.GetNumTargets(); ++i)
 566         delete_target_list.push_back(target_list.GetTargetAtIndex(i));
 567     } else if (argc > 0) {
 568       const uint32_t num_targets = target_list.GetNumTargets();
 569       // Bail out if don't have any targets.
 570       if (num_targets == 0) {
 571         result.AppendError("no targets to delete");
 572         result.SetStatus(eReturnStatusFailed);
 573         return false;
 574       }
 575
 576       for (auto &entry : args.entries()) {
 577         uint32_t target_idx;
 578         if (entry.ref.getAsInteger(0, target_idx)) {
 579           result.AppendErrorWithFormat("invalid target index '%s'\n",
 580                                        entry.c_str());
 581           result.SetStatus(eReturnStatusFailed);
 582           return false;
 583         }
 584         if (target_idx < num_targets) {
 585           target_sp = target_list.GetTargetAtIndex(target_idx);
 586           if (target_sp) {
 587             delete_target_list.push_back(target_sp);
 588             continue;
 589           }
 590         }
 591         if (num_targets > 1)
 592           result.AppendErrorWithFormat("target index %u is out of range, valid "
 593                                        "target indexes are 0 - %u\n",
 594                                        target_idx, num_targets - 1);
 595         else
 596           result.AppendErrorWithFormat(
 597               "target index %u is out of range, the only valid index is 0\n",
 598               target_idx);
 599
 600         result.SetStatus(eReturnStatusFailed);
 601         return false;
 602       }
 603     } else {
 604       target_sp = target_list.GetSelectedTarget();
 605       if (!target_sp) {
 606         result.AppendErrorWithFormat("no target is currently selected\n");
 607         result.SetStatus(eReturnStatusFailed);
 608         return false;
 609       }
 610       delete_target_list.push_back(target_sp);
 611     }
 612
 613     const size_t num_targets_to_delete = delete_target_list.size();
 614     for (size_t idx = 0; idx < num_targets_to_delete; ++idx) {
 615       target_sp = delete_target_list[idx];
 616       target_list.DeleteTarget(target_sp);
 617       target_sp->Destroy();
 618     }
 619     // If "--clean" was specified, prune any orphaned shared modules from
 620     // the global shared module list
 621     if (m_cleanup_option.GetOptionValue()) {
 622       const bool mandatory = true;
 623       ModuleList::RemoveOrphanSharedModules(mandatory);
 624     }
 625     result.GetOutputStream().Printf("%u targets deleted.\n",
 626                                     (uint32_t)num_targets_to_delete);
 627     result.SetStatus(eReturnStatusSuccessFinishResult);
 628
 629     return true;
 630   }
 631
 632   OptionGroupOptions m_option_group;
 633   OptionGroupBoolean m_all_option;
 634   OptionGroupBoolean m_cleanup_option;
 635 };
 636
 637 #pragma mark CommandObjectTargetVariable
 638
 639 //----------------------------------------------------------------------
 640 // "target variable"
 641 //----------------------------------------------------------------------
 642
 643 class CommandObjectTargetVariable : public CommandObjectParsed {
 644   static const uint32_t SHORT_OPTION_FILE = 0x66696c65; // 'file'
 645   static const uint32_t SHORT_OPTION_SHLB = 0x73686c62; // 'shlb'
 646
 647 public:
 648   CommandObjectTargetVariable(CommandInterpreter &interpreter)
 649       : CommandObjectParsed(interpreter, "target variable",
 650                             "Read global variables for the current target, "
 651                             "before or while running a process.",
 652                             nullptr, eCommandRequiresTarget),
 653         m_option_group(),
 654         m_option_variable(false), // Don't include frame options
 655         m_option_format(eFormatDefault),
 656         m_option_compile_units(LLDB_OPT_SET_1, false, "file", SHORT_OPTION_FILE,
 657                                0, eArgTypeFilename,
 658                                "A basename or fullpath to a file that contains "
 659                                "global variables. This option can be "
 660                                "specified multiple times."),
 661         m_option_shared_libraries(
 662             LLDB_OPT_SET_1, false, "shlib", SHORT_OPTION_SHLB, 0,
 663             eArgTypeFilename,
 664             "A basename or fullpath to a shared library to use in the search "
 665             "for global "
 666             "variables. This option can be specified multiple times."),
 667         m_varobj_options() {
 668     CommandArgumentEntry arg;
 669     CommandArgumentData var_name_arg;
 670
 671     // Define the first (and only) variant of this arg.
 672     var_name_arg.arg_type = eArgTypeVarName;
 673     var_name_arg.arg_repetition = eArgRepeatPlus;
 674
 675     // There is only one variant this argument could be; put it into the
 676     // argument entry.
 677     arg.push_back(var_name_arg);
 678
 679     // Push the data for the first argument into the m_arguments vector.
 680     m_arguments.push_back(arg);
 681
 682     m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 683     m_option_group.Append(&m_option_variable, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 684     m_option_group.Append(&m_option_format,
 685                           OptionGroupFormat::OPTION_GROUP_FORMAT |
 686                               OptionGroupFormat::OPTION_GROUP_GDB_FMT,
 687                           LLDB_OPT_SET_1);
 688     m_option_group.Append(&m_option_compile_units, LLDB_OPT_SET_ALL,
 689                           LLDB_OPT_SET_1);
 690     m_option_group.Append(&m_option_shared_libraries, LLDB_OPT_SET_ALL,
 691                           LLDB_OPT_SET_1);
 692     m_option_group.Finalize();
 693   }
 694
 695   ~CommandObjectTargetVariable() override = default;
 696
 697   void DumpValueObject(Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp,
 698                        const char *root_name) {
 699     DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions());
 700
 701     if (!valobj_sp->GetTargetSP()->GetDisplayRuntimeSupportValues() &&
 702         valobj_sp->IsRuntimeSupportValue())
 703       return;
 704
 705     switch (var_sp->GetScope()) {
 706     case eValueTypeVariableGlobal:
 707       if (m_option_variable.show_scope)
 708         s.PutCString("GLOBAL: ");
 709       break;
 710
 711     case eValueTypeVariableStatic:
 712       if (m_option_variable.show_scope)
 713         s.PutCString("STATIC: ");
 714       break;
 715
 716     case eValueTypeVariableArgument:
 717       if (m_option_variable.show_scope)
 718         s.PutCString("   ARG: ");
 719       break;
 720
 721     case eValueTypeVariableLocal:
 722       if (m_option_variable.show_scope)
 723         s.PutCString(" LOCAL: ");
 724       break;
 725
 726     case eValueTypeVariableThreadLocal:
 727       if (m_option_variable.show_scope)
 728         s.PutCString("THREAD: ");
 729       break;
 730
 731     default:
 732       break;
 733     }
 734
 735     if (m_option_variable.show_decl) {
 736       bool show_fullpaths = false;
 737       bool show_module = true;
 738       if (var_sp->DumpDeclaration(&s, show_fullpaths, show_module))
 739         s.PutCString(": ");
 740     }
 741
 742     const Format format = m_option_format.GetFormat();
 743     if (format != eFormatDefault)
 744       options.SetFormat(format);
 745
 746     options.SetRootValueObjectName(root_name);
 747
 748     valobj_sp->Dump(s, options);
 749   }
 750
 751   static size_t GetVariableCallback(void *baton, const char *name,
 752                                     VariableList &variable_list) {
 753     Target *target = static_cast<Target *>(baton);
 754     if (target) {
 755       return target->GetImages().FindGlobalVariables(ConstString(name), true,
 756                                                      UINT32_MAX, variable_list);
 757     }
 758     return 0;
 759   }
 760
 761   Options *GetOptions() override { return &m_option_group; }
 762
 763 protected:
 764   void DumpGlobalVariableList(const ExecutionContext &exe_ctx,
 765                               const SymbolContext &sc,
 766                               const VariableList &variable_list, Stream &s) {
 767     size_t count = variable_list.GetSize();
 768     if (count > 0) {
 769       if (sc.module_sp) {
 770         if (sc.comp_unit) {
 771           s.Printf("Global variables for %s in %s:\n",
 772                    sc.comp_unit->GetPath().c_str(),
 773                    sc.module_sp->GetFileSpec().GetPath().c_str());
 774         } else {
 775           s.Printf("Global variables for %s\n",
 776                    sc.module_sp->GetFileSpec().GetPath().c_str());
 777         }
 778       } else if (sc.comp_unit) {
 779         s.Printf("Global variables for %s\n", sc.comp_unit->GetPath().c_str());
 780       }
 781
 782       for (uint32_t i = 0; i < count; ++i) {
 783         VariableSP var_sp(variable_list.GetVariableAtIndex(i));
 784         if (var_sp) {
 785           ValueObjectSP valobj_sp(ValueObjectVariable::Create(
 786               exe_ctx.GetBestExecutionContextScope(), var_sp));
 787
 788           if (valobj_sp)
 789             DumpValueObject(s, var_sp, valobj_sp,
 790                             var_sp->GetName().GetCString());
 791         }
 792       }
 793     }
 794   }
 795
 796   bool DoExecute(Args &args, CommandReturnObject &result) override {
 797     Target *target = m_exe_ctx.GetTargetPtr();
 798     const size_t argc = args.GetArgumentCount();
 799     Stream &s = result.GetOutputStream();
 800
 801     if (argc > 0) {
 802
 803       // TODO: Convert to entry-based iteration.  Requires converting
 804       // DumpValueObject.
 805       for (size_t idx = 0; idx < argc; ++idx) {
 806         VariableList variable_list;
 807         ValueObjectList valobj_list;
 808
 809         const char *arg = args.GetArgumentAtIndex(idx);
 810         size_t matches = 0;
 811         bool use_var_name = false;
 812         if (m_option_variable.use_regex) {
 813           RegularExpression regex(llvm::StringRef::withNullAsEmpty(arg));
 814           if (!regex.IsValid()) {
 815             result.GetErrorStream().Printf(
 816                 "error: invalid regular expression: '%s'\n", arg);
 817             result.SetStatus(eReturnStatusFailed);
 818             return false;
 819           }
 820           use_var_name = true;
 821           matches = target->GetImages().FindGlobalVariables(
 822               regex, true, UINT32_MAX, variable_list);
 823         } else {
 824           Status error(Variable::GetValuesForVariableExpressionPath(
 825               arg, m_exe_ctx.GetBestExecutionContextScope(),
 826               GetVariableCallback, target, variable_list, valobj_list));
 827           matches = variable_list.GetSize();
 828         }
 829
 830         if (matches == 0) {
 831           result.GetErrorStream().Printf(
 832               "error: can't find global variable '%s'\n", arg);
 833           result.SetStatus(eReturnStatusFailed);
 834           return false;
 835         } else {
 836           for (uint32_t global_idx = 0; global_idx < matches; ++global_idx) {
 837             VariableSP var_sp(variable_list.GetVariableAtIndex(global_idx));
 838             if (var_sp) {
 839               ValueObjectSP valobj_sp(
 840                   valobj_list.GetValueObjectAtIndex(global_idx));
 841               if (!valobj_sp)
 842                 valobj_sp = ValueObjectVariable::Create(
 843                     m_exe_ctx.GetBestExecutionContextScope(), var_sp);
 844
 845               if (valobj_sp)
 846                 DumpValueObject(s, var_sp, valobj_sp,
 847                                 use_var_name ? var_sp->GetName().GetCString()
 848                                              : arg);
 849             }
 850           }
 851         }
 852       }
 853     } else {
 854       const FileSpecList &compile_units =
 855           m_option_compile_units.GetOptionValue().GetCurrentValue();
 856       const FileSpecList &shlibs =
 857           m_option_shared_libraries.GetOptionValue().GetCurrentValue();
 858       SymbolContextList sc_list;
 859       const size_t num_compile_units = compile_units.GetSize();
 860       const size_t num_shlibs = shlibs.GetSize();
 861       if (num_compile_units == 0 && num_shlibs == 0) {
 862         bool success = false;
 863         StackFrame *frame = m_exe_ctx.GetFramePtr();
 864         CompileUnit *comp_unit = nullptr;
 865         if (frame) {
 866           SymbolContext sc = frame->GetSymbolContext(eSymbolContextCompUnit);
 867           if (sc.comp_unit) {
 868             const bool can_create = true;
 869             VariableListSP comp_unit_varlist_sp(
 870                 sc.comp_unit->GetVariableList(can_create));
 871             if (comp_unit_varlist_sp) {
 872               size_t count = comp_unit_varlist_sp->GetSize();
 873               if (count > 0) {
 874                 DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp, s);
 875                 success = true;
 876               }
 877             }
 878           }
 879         }
 880         if (!success) {
 881           if (frame) {
 882             if (comp_unit)
 883               result.AppendErrorWithFormat(
 884                   "no global variables in current compile unit: %s\n",
 885                   comp_unit->GetPath().c_str());
 886             else
 887               result.AppendErrorWithFormat(
 888                   "no debug information for frame %u\n",
 889                   frame->GetFrameIndex());
 890           } else
 891             result.AppendError("'target variable' takes one or more global "
 892                                "variable names as arguments\n");
 893           result.SetStatus(eReturnStatusFailed);
 894         }
 895       } else {
 896         SymbolContextList sc_list;
 897         const bool append = true;
 898         // We have one or more compile unit or shlib
 899         if (num_shlibs > 0) {
 900           for (size_t shlib_idx = 0; shlib_idx < num_shlibs; ++shlib_idx) {
 901             const FileSpec module_file(shlibs.GetFileSpecAtIndex(shlib_idx));
 902             ModuleSpec module_spec(module_file);
 903
 904             ModuleSP module_sp(
 905                 target->GetImages().FindFirstModule(module_spec));
 906             if (module_sp) {
 907               if (num_compile_units > 0) {
 908                 for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
 909                   module_sp->FindCompileUnits(
 910                       compile_units.GetFileSpecAtIndex(cu_idx), append,
 911                       sc_list);
 912               } else {
 913                 SymbolContext sc;
 914                 sc.module_sp = module_sp;
 915                 sc_list.Append(sc);
 916               }
 917             } else {
 918               // Didn't find matching shlib/module in target...
 919               result.AppendErrorWithFormat(
 920                   "target doesn't contain the specified shared library: %s\n",
 921                   module_file.GetPath().c_str());
 922             }
 923           }
 924         } else {
 925           // No shared libraries, we just want to find globals for the compile
 926           // units files that were specified
 927           for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
 928             target->GetImages().FindCompileUnits(
 929                 compile_units.GetFileSpecAtIndex(cu_idx), append, sc_list);
 930         }
 931
 932         const uint32_t num_scs = sc_list.GetSize();
 933         if (num_scs > 0) {
 934           SymbolContext sc;
 935           for (uint32_t sc_idx = 0; sc_idx < num_scs; ++sc_idx) {
 936             if (sc_list.GetContextAtIndex(sc_idx, sc)) {
 937               if (sc.comp_unit) {
 938                 const bool can_create = true;
 939                 VariableListSP comp_unit_varlist_sp(
 940                     sc.comp_unit->GetVariableList(can_create));
 941                 if (comp_unit_varlist_sp)
 942                   DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp,
 943                                          s);
 944               } else if (sc.module_sp) {
 945                 // Get all global variables for this module
 946                 lldb_private::RegularExpression all_globals_regex(
 947                     llvm::StringRef(
 948                         ".")); // Any global with at least one character
 949                 VariableList variable_list;
 950                 sc.module_sp->FindGlobalVariables(all_globals_regex, append,
 951                                                   UINT32_MAX, variable_list);
 952                 DumpGlobalVariableList(m_exe_ctx, sc, variable_list, s);
 953               }
 954             }
 955           }
 956         }
 957       }
 958     }
 959
 960     if (m_interpreter.TruncationWarningNecessary()) {
 961       result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(),
 962                                       m_cmd_name.c_str());
 963       m_interpreter.TruncationWarningGiven();
 964     }
 965
 966     return result.Succeeded();
 967   }
 968
 969   OptionGroupOptions m_option_group;
 970   OptionGroupVariable m_option_variable;
 971   OptionGroupFormat m_option_format;
 972   OptionGroupFileList m_option_compile_units;
 973   OptionGroupFileList m_option_shared_libraries;
 974   OptionGroupValueObjectDisplay m_varobj_options;
 975 };
 976
 977 #pragma mark CommandObjectTargetModulesSearchPathsAdd
 978
 979 class CommandObjectTargetModulesSearchPathsAdd : public CommandObjectParsed {
 980 public:
 981   CommandObjectTargetModulesSearchPathsAdd(CommandInterpreter &interpreter)
 982       : CommandObjectParsed(interpreter, "target modules search-paths add",
 983                             "Add new image search paths substitution pairs to "
 984                             "the current target.",
 985                             nullptr) {
 986     CommandArgumentEntry arg;
 987     CommandArgumentData old_prefix_arg;
 988     CommandArgumentData new_prefix_arg;
 989
 990     // Define the first variant of this arg pair.
 991     old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
 992     old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
 993
 994     // Define the first variant of this arg pair.
 995     new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
 996     new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
 997
 998     // There are two required arguments that must always occur together, i.e. an
 999     // argument "pair".  Because they
1000     // must always occur together, they are treated as two variants of one
1001     // argument rather than two independent
1002     // arguments.  Push them both into the first argument position for
1003     // m_arguments...
1004
1005     arg.push_back(old_prefix_arg);
1006     arg.push_back(new_prefix_arg);
1007
1008     m_arguments.push_back(arg);
1009   }
1010
1011   ~CommandObjectTargetModulesSearchPathsAdd() override = default;
1012
1013 protected:
1014   bool DoExecute(Args &command, CommandReturnObject &result) override {
1015     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1016     if (target) {
1017       const size_t argc = command.GetArgumentCount();
1018       if (argc & 1) {
1019         result.AppendError("add requires an even number of arguments\n");
1020         result.SetStatus(eReturnStatusFailed);
1021       } else {
1022         for (size_t i = 0; i < argc; i += 2) {
1023           const char *from = command.GetArgumentAtIndex(i);
1024           const char *to = command.GetArgumentAtIndex(i + 1);
1025
1026           if (from[0] && to[0]) {
1027             Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
1028             if (log) {
1029               log->Printf("target modules search path adding ImageSearchPath "
1030                           "pair: '%s' -> '%s'",
1031                           from, to);
1032             }
1033             bool last_pair = ((argc - i) == 2);
1034             target->GetImageSearchPathList().Append(
1035                 ConstString(from), ConstString(to),
1036                 last_pair); // Notify if this is the last pair
1037             result.SetStatus(eReturnStatusSuccessFinishNoResult);
1038           } else {
1039             if (from[0])
1040               result.AppendError("<path-prefix> can't be empty\n");
1041             else
1042               result.AppendError("<new-path-prefix> can't be empty\n");
1043             result.SetStatus(eReturnStatusFailed);
1044           }
1045         }
1046       }
1047     } else {
1048       result.AppendError("invalid target\n");
1049       result.SetStatus(eReturnStatusFailed);
1050     }
1051     return result.Succeeded();
1052   }
1053 };
1054
1055 #pragma mark CommandObjectTargetModulesSearchPathsClear
1056
1057 class CommandObjectTargetModulesSearchPathsClear : public CommandObjectParsed {
1058 public:
1059   CommandObjectTargetModulesSearchPathsClear(CommandInterpreter &interpreter)
1060       : CommandObjectParsed(interpreter, "target modules search-paths clear",
1061                             "Clear all current image search path substitution "
1062                             "pairs from the current target.",
1063                             "target modules search-paths clear") {}
1064
1065   ~CommandObjectTargetModulesSearchPathsClear() override = default;
1066
1067 protected:
1068   bool DoExecute(Args &command, CommandReturnObject &result) override {
1069     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1070     if (target) {
1071       bool notify = true;
1072       target->GetImageSearchPathList().Clear(notify);
1073       result.SetStatus(eReturnStatusSuccessFinishNoResult);
1074     } else {
1075       result.AppendError("invalid target\n");
1076       result.SetStatus(eReturnStatusFailed);
1077     }
1078     return result.Succeeded();
1079   }
1080 };
1081
1082 #pragma mark CommandObjectTargetModulesSearchPathsInsert
1083
1084 class CommandObjectTargetModulesSearchPathsInsert : public CommandObjectParsed {
1085 public:
1086   CommandObjectTargetModulesSearchPathsInsert(CommandInterpreter &interpreter)
1087       : CommandObjectParsed(interpreter, "target modules search-paths insert",
1088                             "Insert a new image search path substitution pair "
1089                             "into the current target at the specified index.",
1090                             nullptr) {
1091     CommandArgumentEntry arg1;
1092     CommandArgumentEntry arg2;
1093     CommandArgumentData index_arg;
1094     CommandArgumentData old_prefix_arg;
1095     CommandArgumentData new_prefix_arg;
1096
1097     // Define the first and only variant of this arg.
1098     index_arg.arg_type = eArgTypeIndex;
1099     index_arg.arg_repetition = eArgRepeatPlain;
1100
1101     // Put the one and only variant into the first arg for m_arguments:
1102     arg1.push_back(index_arg);
1103
1104     // Define the first variant of this arg pair.
1105     old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
1106     old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
1107
1108     // Define the first variant of this arg pair.
1109     new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
1110     new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
1111
1112     // There are two required arguments that must always occur together, i.e. an
1113     // argument "pair".  Because they
1114     // must always occur together, they are treated as two variants of one
1115     // argument rather than two independent
1116     // arguments.  Push them both into the same argument position for
1117     // m_arguments...
1118
1119     arg2.push_back(old_prefix_arg);
1120     arg2.push_back(new_prefix_arg);
1121
1122     // Add arguments to m_arguments.
1123     m_arguments.push_back(arg1);
1124     m_arguments.push_back(arg2);
1125   }
1126
1127   ~CommandObjectTargetModulesSearchPathsInsert() override = default;
1128
1129 protected:
1130   bool DoExecute(Args &command, CommandReturnObject &result) override {
1131     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1132     if (target) {
1133       size_t argc = command.GetArgumentCount();
1134       // check for at least 3 arguments and an odd number of parameters
1135       if (argc >= 3 && argc & 1) {
1136         bool success = false;
1137
1138         uint32_t insert_idx = StringConvert::ToUInt32(
1139             command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success);
1140
1141         if (!success) {
1142           result.AppendErrorWithFormat(
1143               "<index> parameter is not an integer: '%s'.\n",
1144               command.GetArgumentAtIndex(0));
1145           result.SetStatus(eReturnStatusFailed);
1146           return result.Succeeded();
1147         }
1148
1149         // shift off the index
1150         command.Shift();
1151         argc = command.GetArgumentCount();
1152
1153         for (uint32_t i = 0; i < argc; i += 2, ++insert_idx) {
1154           const char *from = command.GetArgumentAtIndex(i);
1155           const char *to = command.GetArgumentAtIndex(i + 1);
1156
1157           if (from[0] && to[0]) {
1158             bool last_pair = ((argc - i) == 2);
1159             target->GetImageSearchPathList().Insert(
1160                 ConstString(from), ConstString(to), insert_idx, last_pair);
1161             result.SetStatus(eReturnStatusSuccessFinishNoResult);
1162           } else {
1163             if (from[0])
1164               result.AppendError("<path-prefix> can't be empty\n");
1165             else
1166               result.AppendError("<new-path-prefix> can't be empty\n");
1167             result.SetStatus(eReturnStatusFailed);
1168             return false;
1169           }
1170         }
1171       } else {
1172         result.AppendError("insert requires at least three arguments\n");
1173         result.SetStatus(eReturnStatusFailed);
1174         return result.Succeeded();
1175       }
1176
1177     } else {
1178       result.AppendError("invalid target\n");
1179       result.SetStatus(eReturnStatusFailed);
1180     }
1181     return result.Succeeded();
1182   }
1183 };
1184
1185 #pragma mark CommandObjectTargetModulesSearchPathsList
1186
1187 class CommandObjectTargetModulesSearchPathsList : public CommandObjectParsed {
1188 public:
1189   CommandObjectTargetModulesSearchPathsList(CommandInterpreter &interpreter)
1190       : CommandObjectParsed(interpreter, "target modules search-paths list",
1191                             "List all current image search path substitution "
1192                             "pairs in the current target.",
1193                             "target modules search-paths list") {}
1194
1195   ~CommandObjectTargetModulesSearchPathsList() override = default;
1196
1197 protected:
1198   bool DoExecute(Args &command, CommandReturnObject &result) override {
1199     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1200     if (target) {
1201       if (command.GetArgumentCount() != 0) {
1202         result.AppendError("list takes no arguments\n");
1203         result.SetStatus(eReturnStatusFailed);
1204         return result.Succeeded();
1205       }
1206
1207       target->GetImageSearchPathList().Dump(&result.GetOutputStream());
1208       result.SetStatus(eReturnStatusSuccessFinishResult);
1209     } else {
1210       result.AppendError("invalid target\n");
1211       result.SetStatus(eReturnStatusFailed);
1212     }
1213     return result.Succeeded();
1214   }
1215 };
1216
1217 #pragma mark CommandObjectTargetModulesSearchPathsQuery
1218
1219 class CommandObjectTargetModulesSearchPathsQuery : public CommandObjectParsed {
1220 public:
1221   CommandObjectTargetModulesSearchPathsQuery(CommandInterpreter &interpreter)
1222       : CommandObjectParsed(
1223             interpreter, "target modules search-paths query",
1224             "Transform a path using the first applicable image search path.",
1225             nullptr) {
1226     CommandArgumentEntry arg;
1227     CommandArgumentData path_arg;
1228
1229     // Define the first (and only) variant of this arg.
1230     path_arg.arg_type = eArgTypeDirectoryName;
1231     path_arg.arg_repetition = eArgRepeatPlain;
1232
1233     // There is only one variant this argument could be; put it into the
1234     // argument entry.
1235     arg.push_back(path_arg);
1236
1237     // Push the data for the first argument into the m_arguments vector.
1238     m_arguments.push_back(arg);
1239   }
1240
1241   ~CommandObjectTargetModulesSearchPathsQuery() override = default;
1242
1243 protected:
1244   bool DoExecute(Args &command, CommandReturnObject &result) override {
1245     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1246     if (target) {
1247       if (command.GetArgumentCount() != 1) {
1248         result.AppendError("query requires one argument\n");
1249         result.SetStatus(eReturnStatusFailed);
1250         return result.Succeeded();
1251       }
1252
1253       ConstString orig(command.GetArgumentAtIndex(0));
1254       ConstString transformed;
1255       if (target->GetImageSearchPathList().RemapPath(orig, transformed))
1256         result.GetOutputStream().Printf("%s\n", transformed.GetCString());
1257       else
1258         result.GetOutputStream().Printf("%s\n", orig.GetCString());
1259
1260       result.SetStatus(eReturnStatusSuccessFinishResult);
1261     } else {
1262       result.AppendError("invalid target\n");
1263       result.SetStatus(eReturnStatusFailed);
1264     }
1265     return result.Succeeded();
1266   }
1267 };
1268
1269 //----------------------------------------------------------------------
1270 // Static Helper functions
1271 //----------------------------------------------------------------------
1272 static void DumpModuleArchitecture(Stream &strm, Module *module,
1273                                    bool full_triple, uint32_t width) {
1274   if (module) {
1275     StreamString arch_strm;
1276
1277     if (full_triple)
1278       module->GetArchitecture().DumpTriple(arch_strm);
1279     else
1280       arch_strm.PutCString(module->GetArchitecture().GetArchitectureName());
1281     std::string arch_str = arch_strm.GetString();
1282
1283     if (width)
1284       strm.Printf("%-*s", width, arch_str.c_str());
1285     else
1286       strm.PutCString(arch_str);
1287   }
1288 }
1289
1290 static void DumpModuleUUID(Stream &strm, Module *module) {
1291   if (module && module->GetUUID().IsValid())
1292     module->GetUUID().Dump(&strm);
1293   else
1294     strm.PutCString("                                    ");
1295 }
1296
1297 static uint32_t DumpCompileUnitLineTable(CommandInterpreter &interpreter,
1298                                          Stream &strm, Module *module,
1299                                          const FileSpec &file_spec,
1300                                          bool load_addresses) {
1301   uint32_t num_matches = 0;
1302   if (module) {
1303     SymbolContextList sc_list;
1304     num_matches = module->ResolveSymbolContextsForFileSpec(
1305         file_spec, 0, false, eSymbolContextCompUnit, sc_list);
1306
1307     for (uint32_t i = 0; i < num_matches; ++i) {
1308       SymbolContext sc;
1309       if (sc_list.GetContextAtIndex(i, sc)) {
1310         if (i > 0)
1311           strm << "\n\n";
1312
1313         strm << "Line table for " << *static_cast<FileSpec *>(sc.comp_unit)
1314              << " in `" << module->GetFileSpec().GetFilename() << "\n";
1315         LineTable *line_table = sc.comp_unit->GetLineTable();
1316         if (line_table)
1317           line_table->GetDescription(
1318               &strm, interpreter.GetExecutionContext().GetTargetPtr(),
1319               lldb::eDescriptionLevelBrief);
1320         else
1321           strm << "No line table";
1322       }
1323     }
1324   }
1325   return num_matches;
1326 }
1327
1328 static void DumpFullpath(Stream &strm, const FileSpec *file_spec_ptr,
1329                          uint32_t width) {
1330   if (file_spec_ptr) {
1331     if (width > 0) {
1332       std::string fullpath = file_spec_ptr->GetPath();
1333       strm.Printf("%-*s", width, fullpath.c_str());
1334       return;
1335     } else {
1336       file_spec_ptr->Dump(&strm);
1337       return;
1338     }
1339   }
1340   // Keep the width spacing correct if things go wrong...
1341   if (width > 0)
1342     strm.Printf("%-*s", width, "");
1343 }
1344
1345 static void DumpDirectory(Stream &strm, const FileSpec *file_spec_ptr,
1346                           uint32_t width) {
1347   if (file_spec_ptr) {
1348     if (width > 0)
1349       strm.Printf("%-*s", width, file_spec_ptr->GetDirectory().AsCString(""));
1350     else
1351       file_spec_ptr->GetDirectory().Dump(&strm);
1352     return;
1353   }
1354   // Keep the width spacing correct if things go wrong...
1355   if (width > 0)
1356     strm.Printf("%-*s", width, "");
1357 }
1358
1359 static void DumpBasename(Stream &strm, const FileSpec *file_spec_ptr,
1360                          uint32_t width) {
1361   if (file_spec_ptr) {
1362     if (width > 0)
1363       strm.Printf("%-*s", width, file_spec_ptr->GetFilename().AsCString(""));
1364     else
1365       file_spec_ptr->GetFilename().Dump(&strm);
1366     return;
1367   }
1368   // Keep the width spacing correct if things go wrong...
1369   if (width > 0)
1370     strm.Printf("%-*s", width, "");
1371 }
1372
1373 static size_t DumpModuleObjfileHeaders(Stream &strm, ModuleList &module_list) {
1374   size_t num_dumped = 0;
1375   std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
1376   const size_t num_modules = module_list.GetSize();
1377   if (num_modules > 0) {
1378     strm.Printf("Dumping headers for %" PRIu64 " module(s).\n",
1379                 static_cast<uint64_t>(num_modules));
1380     strm.IndentMore();
1381     for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
1382       Module *module = module_list.GetModulePointerAtIndexUnlocked(image_idx);
1383       if (module) {
1384         if (num_dumped++ > 0) {
1385           strm.EOL();
1386           strm.EOL();
1387         }
1388         ObjectFile *objfile = module->GetObjectFile();
1389         objfile->Dump(&strm);
1390       }
1391     }
1392     strm.IndentLess();
1393   }
1394   return num_dumped;
1395 }
1396
1397 static void DumpModuleSymtab(CommandInterpreter &interpreter, Stream &strm,
1398                              Module *module, SortOrder sort_order) {
1399   if (module) {
1400     SymbolVendor *sym_vendor = module->GetSymbolVendor();
1401     if (sym_vendor) {
1402       Symtab *symtab = sym_vendor->GetSymtab();
1403       if (symtab)
1404         symtab->Dump(&strm, interpreter.GetExecutionContext().GetTargetPtr(),
1405                      sort_order);
1406     }
1407   }
1408 }
1409
1410 static void DumpModuleSections(CommandInterpreter &interpreter, Stream &strm,
1411                                Module *module) {
1412   if (module) {
1413     SectionList *section_list = module->GetSectionList();
1414     if (section_list) {
1415       strm.Printf("Sections for '%s' (%s):\n",
1416                   module->GetSpecificationDescription().c_str(),
1417                   module->GetArchitecture().GetArchitectureName());
1418       strm.IndentMore();
1419       section_list->Dump(&strm,
1420                          interpreter.GetExecutionContext().GetTargetPtr(), true,
1421                          UINT32_MAX);
1422       strm.IndentLess();
1423     }
1424   }
1425 }
1426
1427 static bool DumpModuleSymbolVendor(Stream &strm, Module *module) {
1428   if (module) {
1429     SymbolVendor *symbol_vendor = module->GetSymbolVendor(true);
1430     if (symbol_vendor) {
1431       symbol_vendor->Dump(&strm);
1432       return true;
1433     }
1434   }
1435   return false;
1436 }
1437
1438 static void DumpAddress(ExecutionContextScope *exe_scope,
1439                         const Address &so_addr, bool verbose, Stream &strm) {
1440   strm.IndentMore();
1441   strm.Indent("    Address: ");
1442   so_addr.Dump(&strm, exe_scope, Address::DumpStyleModuleWithFileAddress);
1443   strm.PutCString(" (");
1444   so_addr.Dump(&strm, exe_scope, Address::DumpStyleSectionNameOffset);
1445   strm.PutCString(")\n");
1446   strm.Indent("    Summary: ");
1447   const uint32_t save_indent = strm.GetIndentLevel();
1448   strm.SetIndentLevel(save_indent + 13);
1449   so_addr.Dump(&strm, exe_scope, Address::DumpStyleResolvedDescription);
1450   strm.SetIndentLevel(save_indent);
1451   // Print out detailed address information when verbose is enabled
1452   if (verbose) {
1453     strm.EOL();
1454     so_addr.Dump(&strm, exe_scope, Address::DumpStyleDetailedSymbolContext);
1455   }
1456   strm.IndentLess();
1457 }
1458
1459 static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm,
1460                                   Module *module, uint32_t resolve_mask,
1461                                   lldb::addr_t raw_addr, lldb::addr_t offset,
1462                                   bool verbose) {
1463   if (module) {
1464     lldb::addr_t addr = raw_addr - offset;
1465     Address so_addr;
1466     SymbolContext sc;
1467     Target *target = interpreter.GetExecutionContext().GetTargetPtr();
1468     if (target && !target->GetSectionLoadList().IsEmpty()) {
1469       if (!target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
1470         return false;
1471       else if (so_addr.GetModule().get() != module)
1472         return false;
1473     } else {
1474       if (!module->ResolveFileAddress(addr, so_addr))
1475         return false;
1476     }
1477
1478     ExecutionContextScope *exe_scope =
1479         interpreter.GetExecutionContext().GetBestExecutionContextScope();
1480     DumpAddress(exe_scope, so_addr, verbose, strm);
1481     //        strm.IndentMore();
1482     //        strm.Indent ("    Address: ");
1483     //        so_addr.Dump (&strm, exe_scope,
1484     //        Address::DumpStyleModuleWithFileAddress);
1485     //        strm.PutCString (" (");
1486     //        so_addr.Dump (&strm, exe_scope,
1487     //        Address::DumpStyleSectionNameOffset);
1488     //        strm.PutCString (")\n");
1489     //        strm.Indent ("    Summary: ");
1490     //        const uint32_t save_indent = strm.GetIndentLevel ();
1491     //        strm.SetIndentLevel (save_indent + 13);
1492     //        so_addr.Dump (&strm, exe_scope,
1493     //        Address::DumpStyleResolvedDescription);
1494     //        strm.SetIndentLevel (save_indent);
1495     //        // Print out detailed address information when verbose is enabled
1496     //        if (verbose)
1497     //        {
1498     //            strm.EOL();
1499     //            so_addr.Dump (&strm, exe_scope,
1500     //            Address::DumpStyleDetailedSymbolContext);
1501     //        }
1502     //        strm.IndentLess();
1503     return true;
1504   }
1505
1506   return false;
1507 }
1508
1509 static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter,
1510                                      Stream &strm, Module *module,
1511                                      const char *name, bool name_is_regex,
1512                                      bool verbose) {
1513   if (module) {
1514     SymbolContext sc;
1515
1516     SymbolVendor *sym_vendor = module->GetSymbolVendor();
1517     if (sym_vendor) {
1518       Symtab *symtab = sym_vendor->GetSymtab();
1519       if (symtab) {
1520         std::vector<uint32_t> match_indexes;
1521         ConstString symbol_name(name);
1522         uint32_t num_matches = 0;
1523         if (name_is_regex) {
1524           RegularExpression name_regexp(symbol_name.GetStringRef());
1525           num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType(
1526               name_regexp, eSymbolTypeAny, match_indexes);
1527         } else {
1528           num_matches =
1529               symtab->AppendSymbolIndexesWithName(symbol_name, match_indexes);
1530         }
1531
1532         if (num_matches > 0) {
1533           strm.Indent();
1534           strm.Printf("%u symbols match %s'%s' in ", num_matches,
1535                       name_is_regex ? "the regular expression " : "", name);
1536           DumpFullpath(strm, &module->GetFileSpec(), 0);
1537           strm.PutCString(":\n");
1538           strm.IndentMore();
1539           for (uint32_t i = 0; i < num_matches; ++i) {
1540             Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
1541             if (symbol && symbol->ValueIsAddress()) {
1542               DumpAddress(interpreter.GetExecutionContext()
1543                               .GetBestExecutionContextScope(),
1544                           symbol->GetAddressRef(), verbose, strm);
1545             }
1546           }
1547           strm.IndentLess();
1548           return num_matches;
1549         }
1550       }
1551     }
1552   }
1553   return 0;
1554 }
1555
1556 static void DumpSymbolContextList(ExecutionContextScope *exe_scope,
1557                                   Stream &strm, SymbolContextList &sc_list,
1558                                   bool verbose) {
1559   strm.IndentMore();
1560
1561   const uint32_t num_matches = sc_list.GetSize();
1562
1563   for (uint32_t i = 0; i < num_matches; ++i) {
1564     SymbolContext sc;
1565     if (sc_list.GetContextAtIndex(i, sc)) {
1566       AddressRange range;
1567
1568       sc.GetAddressRange(eSymbolContextEverything, 0, true, range);
1569
1570       DumpAddress(exe_scope, range.GetBaseAddress(), verbose, strm);
1571     }
1572   }
1573   strm.IndentLess();
1574 }
1575
1576 static size_t LookupFunctionInModule(CommandInterpreter &interpreter,
1577                                      Stream &strm, Module *module,
1578                                      const char *name, bool name_is_regex,
1579                                      bool include_inlines, bool include_symbols,
1580                                      bool verbose) {
1581   if (module && name && name[0]) {
1582     SymbolContextList sc_list;
1583     const bool append = true;
1584     size_t num_matches = 0;
1585     if (name_is_regex) {
1586       RegularExpression function_name_regex((llvm::StringRef(name)));
1587       num_matches = module->FindFunctions(function_name_regex, include_symbols,
1588                                           include_inlines, append, sc_list);
1589     } else {
1590       ConstString function_name(name);
1591       num_matches = module->FindFunctions(
1592           function_name, nullptr, eFunctionNameTypeAuto, include_symbols,
1593           include_inlines, append, sc_list);
1594     }
1595
1596     if (num_matches) {
1597       strm.Indent();
1598       strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
1599                   num_matches > 1 ? "es" : "");
1600       DumpFullpath(strm, &module->GetFileSpec(), 0);
1601       strm.PutCString(":\n");
1602       DumpSymbolContextList(
1603           interpreter.GetExecutionContext().GetBestExecutionContextScope(),
1604           strm, sc_list, verbose);
1605     }
1606     return num_matches;
1607   }
1608   return 0;
1609 }
1610
1611 static size_t LookupTypeInModule(CommandInterpreter &interpreter, Stream &strm,
1612                                  Module *module, const char *name_cstr,
1613                                  bool name_is_regex) {
1614   if (module && name_cstr && name_cstr[0]) {
1615     TypeList type_list;
1616     const uint32_t max_num_matches = UINT32_MAX;
1617     size_t num_matches = 0;
1618     bool name_is_fully_qualified = false;
1619     SymbolContext sc;
1620
1621     ConstString name(name_cstr);
1622     llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
1623     num_matches =
1624         module->FindTypes(sc, name, name_is_fully_qualified, max_num_matches,
1625                           searched_symbol_files, type_list);
1626
1627     if (num_matches) {
1628       strm.Indent();
1629       strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
1630                   num_matches > 1 ? "es" : "");
1631       DumpFullpath(strm, &module->GetFileSpec(), 0);
1632       strm.PutCString(":\n");
1633       for (TypeSP type_sp : type_list.Types()) {
1634         if (type_sp) {
1635           // Resolve the clang type so that any forward references
1636           // to types that haven't yet been parsed will get parsed.
1637           type_sp->GetFullCompilerType();
1638           type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
1639           // Print all typedef chains
1640           TypeSP typedef_type_sp(type_sp);
1641           TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
1642           while (typedefed_type_sp) {
1643             strm.EOL();
1644             strm.Printf("     typedef '%s': ",
1645                         typedef_type_sp->GetName().GetCString());
1646             typedefed_type_sp->GetFullCompilerType();
1647             typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull,
1648                                               true);
1649             typedef_type_sp = typedefed_type_sp;
1650             typedefed_type_sp = typedef_type_sp->GetTypedefType();
1651           }
1652         }
1653         strm.EOL();
1654       }
1655     }
1656     return num_matches;
1657   }
1658   return 0;
1659 }
1660
1661 static size_t LookupTypeHere(CommandInterpreter &interpreter, Stream &strm,
1662                              const SymbolContext &sym_ctx,
1663                              const char *name_cstr, bool name_is_regex) {
1664   if (!sym_ctx.module_sp)
1665     return 0;
1666
1667   TypeList type_list;
1668   const uint32_t max_num_matches = UINT32_MAX;
1669   size_t num_matches = 1;
1670   bool name_is_fully_qualified = false;
1671
1672   ConstString name(name_cstr);
1673   llvm::DenseSet<SymbolFile *> searched_symbol_files;
1674   num_matches = sym_ctx.module_sp->FindTypes(
1675       sym_ctx, name, name_is_fully_qualified, max_num_matches,
1676       searched_symbol_files, type_list);
1677
1678   if (num_matches) {
1679     strm.Indent();
1680     strm.PutCString("Best match found in ");
1681     DumpFullpath(strm, &sym_ctx.module_sp->GetFileSpec(), 0);
1682     strm.PutCString(":\n");
1683
1684     TypeSP type_sp(type_list.GetTypeAtIndex(0));
1685     if (type_sp) {
1686       // Resolve the clang type so that any forward references
1687       // to types that haven't yet been parsed will get parsed.
1688       type_sp->GetFullCompilerType();
1689       type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
1690       // Print all typedef chains
1691       TypeSP typedef_type_sp(type_sp);
1692       TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
1693       while (typedefed_type_sp) {
1694         strm.EOL();
1695         strm.Printf("     typedef '%s': ",
1696                     typedef_type_sp->GetName().GetCString());
1697         typedefed_type_sp->GetFullCompilerType();
1698         typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
1699         typedef_type_sp = typedefed_type_sp;
1700         typedefed_type_sp = typedef_type_sp->GetTypedefType();
1701       }
1702     }
1703     strm.EOL();
1704   }
1705   return num_matches;
1706 }
1707
1708 static uint32_t LookupFileAndLineInModule(CommandInterpreter &interpreter,
1709                                           Stream &strm, Module *module,
1710                                           const FileSpec &file_spec,
1711                                           uint32_t line, bool check_inlines,
1712                                           bool verbose) {
1713   if (module && file_spec) {
1714     SymbolContextList sc_list;
1715     const uint32_t num_matches = module->ResolveSymbolContextsForFileSpec(
1716         file_spec, line, check_inlines, eSymbolContextEverything, sc_list);
1717     if (num_matches > 0) {
1718       strm.Indent();
1719       strm.Printf("%u match%s found in ", num_matches,
1720                   num_matches > 1 ? "es" : "");
1721       strm << file_spec;
1722       if (line > 0)
1723         strm.Printf(":%u", line);
1724       strm << " in ";
1725       DumpFullpath(strm, &module->GetFileSpec(), 0);
1726       strm.PutCString(":\n");
1727       DumpSymbolContextList(
1728           interpreter.GetExecutionContext().GetBestExecutionContextScope(),
1729           strm, sc_list, verbose);
1730       return num_matches;
1731     }
1732   }
1733   return 0;
1734 }
1735
1736 static size_t FindModulesByName(Target *target, const char *module_name,
1737                                 ModuleList &module_list,
1738                                 bool check_global_list) {
1739   FileSpec module_file_spec(module_name, false);
1740   ModuleSpec module_spec(module_file_spec);
1741
1742   const size_t initial_size = module_list.GetSize();
1743
1744   if (check_global_list) {
1745     // Check the global list
1746     std::lock_guard<std::recursive_mutex> guard(
1747         Module::GetAllocationModuleCollectionMutex());
1748     const size_t num_modules = Module::GetNumberAllocatedModules();
1749     ModuleSP module_sp;
1750     for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
1751       Module *module = Module::GetAllocatedModuleAtIndex(image_idx);
1752
1753       if (module) {
1754         if (module->MatchesModuleSpec(module_spec)) {
1755           module_sp = module->shared_from_this();
1756           module_list.AppendIfNeeded(module_sp);
1757         }
1758       }
1759     }
1760   } else {
1761     if (target) {
1762       const size_t num_matches =
1763           target->GetImages().FindModules(module_spec, module_list);
1764
1765       // Not found in our module list for our target, check the main
1766       // shared module list in case it is a extra file used somewhere
1767       // else
1768       if (num_matches == 0) {
1769         module_spec.GetArchitecture() = target->GetArchitecture();
1770         ModuleList::FindSharedModules(module_spec, module_list);
1771       }
1772     } else {
1773       ModuleList::FindSharedModules(module_spec, module_list);
1774     }
1775   }
1776
1777   return module_list.GetSize() - initial_size;
1778 }
1779
1780 #pragma mark CommandObjectTargetModulesModuleAutoComplete
1781
1782 //----------------------------------------------------------------------
1783 // A base command object class that can auto complete with module file
1784 // paths
1785 //----------------------------------------------------------------------
1786
1787 class CommandObjectTargetModulesModuleAutoComplete
1788     : public CommandObjectParsed {
1789 public:
1790   CommandObjectTargetModulesModuleAutoComplete(CommandInterpreter &interpreter,
1791                                                const char *name,
1792                                                const char *help,
1793                                                const char *syntax)
1794       : CommandObjectParsed(interpreter, name, help, syntax) {
1795     CommandArgumentEntry arg;
1796     CommandArgumentData file_arg;
1797
1798     // Define the first (and only) variant of this arg.
1799     file_arg.arg_type = eArgTypeFilename;
1800     file_arg.arg_repetition = eArgRepeatStar;
1801
1802     // There is only one variant this argument could be; put it into the
1803     // argument entry.
1804     arg.push_back(file_arg);
1805
1806     // Push the data for the first argument into the m_arguments vector.
1807     m_arguments.push_back(arg);
1808   }
1809
1810   ~CommandObjectTargetModulesModuleAutoComplete() override = default;
1811
1812   int HandleArgumentCompletion(Args &input, int &cursor_index,
1813                                int &cursor_char_position,
1814                                OptionElementVector &opt_element_vector,
1815                                int match_start_point, int max_return_elements,
1816                                bool &word_complete,
1817                                StringList &matches) override {
1818     // Arguments are the standard module completer.
1819     std::string completion_str(input.GetArgumentAtIndex(cursor_index));
1820     completion_str.erase(cursor_char_position);
1821
1822     CommandCompletions::InvokeCommonCompletionCallbacks(
1823         GetCommandInterpreter(), CommandCompletions::eModuleCompletion,
1824         completion_str.c_str(), match_start_point, max_return_elements, nullptr,
1825         word_complete, matches);
1826     return matches.GetSize();
1827   }
1828 };
1829
1830 #pragma mark CommandObjectTargetModulesSourceFileAutoComplete
1831
1832 //----------------------------------------------------------------------
1833 // A base command object class that can auto complete with module source
1834 // file paths
1835 //----------------------------------------------------------------------
1836
1837 class CommandObjectTargetModulesSourceFileAutoComplete
1838     : public CommandObjectParsed {
1839 public:
1840   CommandObjectTargetModulesSourceFileAutoComplete(
1841       CommandInterpreter &interpreter, const char *name, const char *help,
1842       const char *syntax, uint32_t flags)
1843       : CommandObjectParsed(interpreter, name, help, syntax, flags) {
1844     CommandArgumentEntry arg;
1845     CommandArgumentData source_file_arg;
1846
1847     // Define the first (and only) variant of this arg.
1848     source_file_arg.arg_type = eArgTypeSourceFile;
1849     source_file_arg.arg_repetition = eArgRepeatPlus;
1850
1851     // There is only one variant this argument could be; put it into the
1852     // argument entry.
1853     arg.push_back(source_file_arg);
1854
1855     // Push the data for the first argument into the m_arguments vector.
1856     m_arguments.push_back(arg);
1857   }
1858
1859   ~CommandObjectTargetModulesSourceFileAutoComplete() override = default;
1860
1861   int HandleArgumentCompletion(Args &input, int &cursor_index,
1862                                int &cursor_char_position,
1863                                OptionElementVector &opt_element_vector,
1864                                int match_start_point, int max_return_elements,
1865                                bool &word_complete,
1866                                StringList &matches) override {
1867     // Arguments are the standard source file completer.
1868     std::string completion_str(input.GetArgumentAtIndex(cursor_index));
1869     completion_str.erase(cursor_char_position);
1870
1871     CommandCompletions::InvokeCommonCompletionCallbacks(
1872         GetCommandInterpreter(), CommandCompletions::eSourceFileCompletion,
1873         completion_str.c_str(), match_start_point, max_return_elements, nullptr,
1874         word_complete, matches);
1875     return matches.GetSize();
1876   }
1877 };
1878
1879 #pragma mark CommandObjectTargetModulesDumpObjfile
1880
1881 class CommandObjectTargetModulesDumpObjfile
1882     : public CommandObjectTargetModulesModuleAutoComplete {
1883 public:
1884   CommandObjectTargetModulesDumpObjfile(CommandInterpreter &interpreter)
1885       : CommandObjectTargetModulesModuleAutoComplete(
1886             interpreter, "target modules dump objfile",
1887             "Dump the object file headers from one or more target modules.",
1888             nullptr) {}
1889
1890   ~CommandObjectTargetModulesDumpObjfile() override = default;
1891
1892 protected:
1893   bool DoExecute(Args &command, CommandReturnObject &result) override {
1894     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1895     if (target == nullptr) {
1896       result.AppendError("invalid target, create a debug target using the "
1897                          "'target create' command");
1898       result.SetStatus(eReturnStatusFailed);
1899       return false;
1900     }
1901
1902     uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
1903     result.GetOutputStream().SetAddressByteSize(addr_byte_size);
1904     result.GetErrorStream().SetAddressByteSize(addr_byte_size);
1905
1906     size_t num_dumped = 0;
1907     if (command.GetArgumentCount() == 0) {
1908       // Dump all headers for all modules images
1909       num_dumped = DumpModuleObjfileHeaders(result.GetOutputStream(),
1910                                             target->GetImages());
1911       if (num_dumped == 0) {
1912         result.AppendError("the target has no associated executable images");
1913         result.SetStatus(eReturnStatusFailed);
1914       }
1915     } else {
1916       // Find the modules that match the basename or full path.
1917       ModuleList module_list;
1918       const char *arg_cstr;
1919       for (int arg_idx = 0;
1920            (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
1921            ++arg_idx) {
1922         size_t num_matched =
1923             FindModulesByName(target, arg_cstr, module_list, true);
1924         if (num_matched == 0) {
1925           result.AppendWarningWithFormat(
1926               "Unable to find an image that matches '%s'.\n", arg_cstr);
1927         }
1928       }
1929       // Dump all the modules we found.
1930       num_dumped =
1931           DumpModuleObjfileHeaders(result.GetOutputStream(), module_list);
1932     }
1933
1934     if (num_dumped > 0) {
1935       result.SetStatus(eReturnStatusSuccessFinishResult);
1936     } else {
1937       result.AppendError("no matching executable images found");
1938       result.SetStatus(eReturnStatusFailed);
1939     }
1940     return result.Succeeded();
1941   }
1942 };
1943
1944 #pragma mark CommandObjectTargetModulesDumpSymtab
1945
1946 static OptionEnumValueElement g_sort_option_enumeration[4] = {
1947     {eSortOrderNone, "none",
1948      "No sorting, use the original symbol table order."},
1949     {eSortOrderByAddress, "address", "Sort output by symbol address."},
1950     {eSortOrderByName, "name", "Sort output by symbol name."},
1951     {0, nullptr, nullptr}};
1952
1953 static OptionDefinition g_target_modules_dump_symtab_options[] = {
1954     // clang-format off
1955   { LLDB_OPT_SET_1, false, "sort", 's', OptionParser::eRequiredArgument, nullptr, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table." }
1956     // clang-format on
1957 };
1958
1959 class CommandObjectTargetModulesDumpSymtab
1960     : public CommandObjectTargetModulesModuleAutoComplete {
1961 public:
1962   CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter)
1963       : CommandObjectTargetModulesModuleAutoComplete(
1964             interpreter, "target modules dump symtab",
1965             "Dump the symbol table from one or more target modules.", nullptr),
1966         m_options() {}
1967
1968   ~CommandObjectTargetModulesDumpSymtab() override = default;
1969
1970   Options *GetOptions() override { return &m_options; }
1971
1972   class CommandOptions : public Options {
1973   public:
1974     CommandOptions() : Options(), m_sort_order(eSortOrderNone) {}
1975
1976     ~CommandOptions() override = default;
1977
1978     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1979                           ExecutionContext *execution_context) override {
1980       Status error;
1981       const int short_option = m_getopt_table[option_idx].val;
1982
1983       switch (short_option) {
1984       case 's':
1985         m_sort_order = (SortOrder)Args::StringToOptionEnum(
1986             option_arg, GetDefinitions()[option_idx].enum_values,
1987             eSortOrderNone, error);
1988         break;
1989
1990       default:
1991         error.SetErrorStringWithFormat("invalid short option character '%c'",
1992                                        short_option);
1993         break;
1994       }
1995       return error;
1996     }
1997
1998     void OptionParsingStarting(ExecutionContext *execution_context) override {
1999       m_sort_order = eSortOrderNone;
2000     }
2001
2002     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2003       return llvm::makeArrayRef(g_target_modules_dump_symtab_options);
2004     }
2005
2006     SortOrder m_sort_order;
2007   };
2008
2009 protected:
2010   bool DoExecute(Args &command, CommandReturnObject &result) override {
2011     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2012     if (target == nullptr) {
2013       result.AppendError("invalid target, create a debug target using the "
2014                          "'target create' command");
2015       result.SetStatus(eReturnStatusFailed);
2016       return false;
2017     } else {
2018       uint32_t num_dumped = 0;
2019
2020       uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2021       result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2022       result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2023
2024       if (command.GetArgumentCount() == 0) {
2025         // Dump all sections for all modules images
2026         std::lock_guard<std::recursive_mutex> guard(
2027             target->GetImages().GetMutex());
2028         const size_t num_modules = target->GetImages().GetSize();
2029         if (num_modules > 0) {
2030           result.GetOutputStream().Printf("Dumping symbol table for %" PRIu64
2031                                           " modules.\n",
2032                                           (uint64_t)num_modules);
2033           for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
2034             if (num_dumped > 0) {
2035               result.GetOutputStream().EOL();
2036               result.GetOutputStream().EOL();
2037             }
2038             if (m_interpreter.WasInterrupted())
2039               break;
2040             num_dumped++;
2041             DumpModuleSymtab(
2042                 m_interpreter, result.GetOutputStream(),
2043                 target->GetImages().GetModulePointerAtIndexUnlocked(image_idx),
2044                 m_options.m_sort_order);
2045           }
2046         } else {
2047           result.AppendError("the target has no associated executable images");
2048           result.SetStatus(eReturnStatusFailed);
2049           return false;
2050         }
2051       } else {
2052         // Dump specified images (by basename or fullpath)
2053         const char *arg_cstr;
2054         for (int arg_idx = 0;
2055              (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2056              ++arg_idx) {
2057           ModuleList module_list;
2058           const size_t num_matches =
2059               FindModulesByName(target, arg_cstr, module_list, true);
2060           if (num_matches > 0) {
2061             for (size_t i = 0; i < num_matches; ++i) {
2062               Module *module = module_list.GetModulePointerAtIndex(i);
2063               if (module) {
2064                 if (num_dumped > 0) {
2065                   result.GetOutputStream().EOL();
2066                   result.GetOutputStream().EOL();
2067                 }
2068                 if (m_interpreter.WasInterrupted())
2069                   break;
2070                 num_dumped++;
2071                 DumpModuleSymtab(m_interpreter, result.GetOutputStream(),
2072                                  module, m_options.m_sort_order);
2073               }
2074             }
2075           } else
2076             result.AppendWarningWithFormat(
2077                 "Unable to find an image that matches '%s'.\n", arg_cstr);
2078         }
2079       }
2080
2081       if (num_dumped > 0)
2082         result.SetStatus(eReturnStatusSuccessFinishResult);
2083       else {
2084         result.AppendError("no matching executable images found");
2085         result.SetStatus(eReturnStatusFailed);
2086       }
2087     }
2088     return result.Succeeded();
2089   }
2090
2091   CommandOptions m_options;
2092 };
2093
2094 #pragma mark CommandObjectTargetModulesDumpSections
2095
2096 //----------------------------------------------------------------------
2097 // Image section dumping command
2098 //----------------------------------------------------------------------
2099
2100 class CommandObjectTargetModulesDumpSections
2101     : public CommandObjectTargetModulesModuleAutoComplete {
2102 public:
2103   CommandObjectTargetModulesDumpSections(CommandInterpreter &interpreter)
2104       : CommandObjectTargetModulesModuleAutoComplete(
2105             interpreter, "target modules dump sections",
2106             "Dump the sections from one or more target modules.",
2107             //"target modules dump sections [<file1> ...]")
2108             nullptr) {}
2109
2110   ~CommandObjectTargetModulesDumpSections() override = default;
2111
2112 protected:
2113   bool DoExecute(Args &command, CommandReturnObject &result) override {
2114     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2115     if (target == nullptr) {
2116       result.AppendError("invalid target, create a debug target using the "
2117                          "'target create' command");
2118       result.SetStatus(eReturnStatusFailed);
2119       return false;
2120     } else {
2121       uint32_t num_dumped = 0;
2122
2123       uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2124       result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2125       result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2126
2127       if (command.GetArgumentCount() == 0) {
2128         // Dump all sections for all modules images
2129         const size_t num_modules = target->GetImages().GetSize();
2130         if (num_modules > 0) {
2131           result.GetOutputStream().Printf("Dumping sections for %" PRIu64
2132                                           " modules.\n",
2133                                           (uint64_t)num_modules);
2134           for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
2135             if (m_interpreter.WasInterrupted())
2136               break;
2137             num_dumped++;
2138             DumpModuleSections(
2139                 m_interpreter, result.GetOutputStream(),
2140                 target->GetImages().GetModulePointerAtIndex(image_idx));
2141           }
2142         } else {
2143           result.AppendError("the target has no associated executable images");
2144           result.SetStatus(eReturnStatusFailed);
2145           return false;
2146         }
2147       } else {
2148         // Dump specified images (by basename or fullpath)
2149         const char *arg_cstr;
2150         for (int arg_idx = 0;
2151              (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2152              ++arg_idx) {
2153           ModuleList module_list;
2154           const size_t num_matches =
2155               FindModulesByName(target, arg_cstr, module_list, true);
2156           if (num_matches > 0) {
2157             for (size_t i = 0; i < num_matches; ++i) {
2158               if (m_interpreter.WasInterrupted())
2159                 break;
2160               Module *module = module_list.GetModulePointerAtIndex(i);
2161               if (module) {
2162                 num_dumped++;
2163                 DumpModuleSections(m_interpreter, result.GetOutputStream(),
2164                                    module);
2165               }
2166             }
2167           } else {
2168             // Check the global list
2169             std::lock_guard<std::recursive_mutex> guard(
2170                 Module::GetAllocationModuleCollectionMutex());
2171
2172             result.AppendWarningWithFormat(
2173                 "Unable to find an image that matches '%s'.\n", arg_cstr);
2174           }
2175         }
2176       }
2177
2178       if (num_dumped > 0)
2179         result.SetStatus(eReturnStatusSuccessFinishResult);
2180       else {
2181         result.AppendError("no matching executable images found");
2182         result.SetStatus(eReturnStatusFailed);
2183       }
2184     }
2185     return result.Succeeded();
2186   }
2187 };
2188
2189 #pragma mark CommandObjectTargetModulesDumpSymfile
2190
2191 //----------------------------------------------------------------------
2192 // Image debug symbol dumping command
2193 //----------------------------------------------------------------------
2194
2195 class CommandObjectTargetModulesDumpSymfile
2196     : public CommandObjectTargetModulesModuleAutoComplete {
2197 public:
2198   CommandObjectTargetModulesDumpSymfile(CommandInterpreter &interpreter)
2199       : CommandObjectTargetModulesModuleAutoComplete(
2200             interpreter, "target modules dump symfile",
2201             "Dump the debug symbol file for one or more target modules.",
2202             //"target modules dump symfile [<file1> ...]")
2203             nullptr) {}
2204
2205   ~CommandObjectTargetModulesDumpSymfile() override = default;
2206
2207 protected:
2208   bool DoExecute(Args &command, CommandReturnObject &result) override {
2209     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2210     if (target == nullptr) {
2211       result.AppendError("invalid target, create a debug target using the "
2212                          "'target create' command");
2213       result.SetStatus(eReturnStatusFailed);
2214       return false;
2215     } else {
2216       uint32_t num_dumped = 0;
2217
2218       uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2219       result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2220       result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2221
2222       if (command.GetArgumentCount() == 0) {
2223         // Dump all sections for all modules images
2224         const ModuleList &target_modules = target->GetImages();
2225         std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
2226         const size_t num_modules = target_modules.GetSize();
2227         if (num_modules > 0) {
2228           result.GetOutputStream().Printf("Dumping debug symbols for %" PRIu64
2229                                           " modules.\n",
2230                                           (uint64_t)num_modules);
2231           for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) {
2232             if (m_interpreter.WasInterrupted())
2233               break;
2234             if (DumpModuleSymbolVendor(
2235                     result.GetOutputStream(),
2236                     target_modules.GetModulePointerAtIndexUnlocked(image_idx)))
2237               num_dumped++;
2238           }
2239         } else {
2240           result.AppendError("the target has no associated executable images");
2241           result.SetStatus(eReturnStatusFailed);
2242           return false;
2243         }
2244       } else {
2245         // Dump specified images (by basename or fullpath)
2246         const char *arg_cstr;
2247         for (int arg_idx = 0;
2248              (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2249              ++arg_idx) {
2250           ModuleList module_list;
2251           const size_t num_matches =
2252               FindModulesByName(target, arg_cstr, module_list, true);
2253           if (num_matches > 0) {
2254             for (size_t i = 0; i < num_matches; ++i) {
2255               if (m_interpreter.WasInterrupted())
2256                 break;
2257               Module *module = module_list.GetModulePointerAtIndex(i);
2258               if (module) {
2259                 if (DumpModuleSymbolVendor(result.GetOutputStream(), module))
2260                   num_dumped++;
2261               }
2262             }
2263           } else
2264             result.AppendWarningWithFormat(
2265                 "Unable to find an image that matches '%s'.\n", arg_cstr);
2266         }
2267       }
2268
2269       if (num_dumped > 0)
2270         result.SetStatus(eReturnStatusSuccessFinishResult);
2271       else {
2272         result.AppendError("no matching executable images found");
2273         result.SetStatus(eReturnStatusFailed);
2274       }
2275     }
2276     return result.Succeeded();
2277   }
2278 };
2279
2280 #pragma mark CommandObjectTargetModulesDumpLineTable
2281
2282 //----------------------------------------------------------------------
2283 // Image debug line table dumping command
2284 //----------------------------------------------------------------------
2285
2286 class CommandObjectTargetModulesDumpLineTable
2287     : public CommandObjectTargetModulesSourceFileAutoComplete {
2288 public:
2289   CommandObjectTargetModulesDumpLineTable(CommandInterpreter &interpreter)
2290       : CommandObjectTargetModulesSourceFileAutoComplete(
2291             interpreter, "target modules dump line-table",
2292             "Dump the line table for one or more compilation units.", nullptr,
2293             eCommandRequiresTarget) {}
2294
2295   ~CommandObjectTargetModulesDumpLineTable() override = default;
2296
2297 protected:
2298   bool DoExecute(Args &command, CommandReturnObject &result) override {
2299     Target *target = m_exe_ctx.GetTargetPtr();
2300     uint32_t total_num_dumped = 0;
2301
2302     uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2303     result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2304     result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2305
2306     if (command.GetArgumentCount() == 0) {
2307       result.AppendError("file option must be specified.");
2308       result.SetStatus(eReturnStatusFailed);
2309       return result.Succeeded();
2310     } else {
2311       // Dump specified images (by basename or fullpath)
2312       const char *arg_cstr;
2313       for (int arg_idx = 0;
2314            (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2315            ++arg_idx) {
2316         FileSpec file_spec(arg_cstr, false);
2317
2318         const ModuleList &target_modules = target->GetImages();
2319         std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
2320         const size_t num_modules = target_modules.GetSize();
2321         if (num_modules > 0) {
2322           uint32_t num_dumped = 0;
2323           for (uint32_t i = 0; i < num_modules; ++i) {
2324             if (m_interpreter.WasInterrupted())
2325               break;
2326             if (DumpCompileUnitLineTable(
2327                     m_interpreter, result.GetOutputStream(),
2328                     target_modules.GetModulePointerAtIndexUnlocked(i),
2329                     file_spec, m_exe_ctx.GetProcessPtr() &&
2330                                    m_exe_ctx.GetProcessRef().IsAlive()))
2331               num_dumped++;
2332           }
2333           if (num_dumped == 0)
2334             result.AppendWarningWithFormat(
2335                 "No source filenames matched '%s'.\n", arg_cstr);
2336           else
2337             total_num_dumped += num_dumped;
2338         }
2339       }
2340     }
2341
2342     if (total_num_dumped > 0)
2343       result.SetStatus(eReturnStatusSuccessFinishResult);
2344     else {
2345       result.AppendError("no source filenames matched any command arguments");
2346       result.SetStatus(eReturnStatusFailed);
2347     }
2348     return result.Succeeded();
2349   }
2350 };
2351
2352 #pragma mark CommandObjectTargetModulesDump
2353
2354 //----------------------------------------------------------------------
2355 // Dump multi-word command for target modules
2356 //----------------------------------------------------------------------
2357
2358 class CommandObjectTargetModulesDump : public CommandObjectMultiword {
2359 public:
2360   //------------------------------------------------------------------
2361   // Constructors and Destructors
2362   //------------------------------------------------------------------
2363   CommandObjectTargetModulesDump(CommandInterpreter &interpreter)
2364       : CommandObjectMultiword(interpreter, "target modules dump",
2365                                "Commands for dumping information about one or "
2366                                "more target modules.",
2367                                "target modules dump "
2368                                "[headers|symtab|sections|symfile|line-table] "
2369                                "[<file1> <file2> ...]") {
2370     LoadSubCommand("objfile",
2371                    CommandObjectSP(
2372                        new CommandObjectTargetModulesDumpObjfile(interpreter)));
2373     LoadSubCommand(
2374         "symtab",
2375         CommandObjectSP(new CommandObjectTargetModulesDumpSymtab(interpreter)));
2376     LoadSubCommand("sections",
2377                    CommandObjectSP(new CommandObjectTargetModulesDumpSections(
2378                        interpreter)));
2379     LoadSubCommand("symfile",
2380                    CommandObjectSP(
2381                        new CommandObjectTargetModulesDumpSymfile(interpreter)));
2382     LoadSubCommand("line-table",
2383                    CommandObjectSP(new CommandObjectTargetModulesDumpLineTable(
2384                        interpreter)));
2385   }
2386
2387   ~CommandObjectTargetModulesDump() override = default;
2388 };
2389
2390 class CommandObjectTargetModulesAdd : public CommandObjectParsed {
2391 public:
2392   CommandObjectTargetModulesAdd(CommandInterpreter &interpreter)
2393       : CommandObjectParsed(interpreter, "target modules add",
2394                             "Add a new module to the current target's modules.",
2395                             "target modules add [<module>]"),
2396         m_option_group(),
2397         m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0,
2398                       eArgTypeFilename, "Fullpath to a stand alone debug "
2399                                         "symbols file for when debug symbols "
2400                                         "are not in the executable.") {
2401     m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL,
2402                           LLDB_OPT_SET_1);
2403     m_option_group.Append(&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2404     m_option_group.Finalize();
2405   }
2406
2407   ~CommandObjectTargetModulesAdd() override = default;
2408
2409   Options *GetOptions() override { return &m_option_group; }
2410
2411   int HandleArgumentCompletion(Args &input, int &cursor_index,
2412                                int &cursor_char_position,
2413                                OptionElementVector &opt_element_vector,
2414                                int match_start_point, int max_return_elements,
2415                                bool &word_complete,
2416                                StringList &matches) override {
2417     std::string completion_str(input.GetArgumentAtIndex(cursor_index));
2418     completion_str.erase(cursor_char_position);
2419
2420     CommandCompletions::InvokeCommonCompletionCallbacks(
2421         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
2422         completion_str.c_str(), match_start_point, max_return_elements, nullptr,
2423         word_complete, matches);
2424     return matches.GetSize();
2425   }
2426
2427 protected:
2428   OptionGroupOptions m_option_group;
2429   OptionGroupUUID m_uuid_option_group;
2430   OptionGroupFile m_symbol_file;
2431
2432   bool DoExecute(Args &args, CommandReturnObject &result) override {
2433     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2434     if (target == nullptr) {
2435       result.AppendError("invalid target, create a debug target using the "
2436                          "'target create' command");
2437       result.SetStatus(eReturnStatusFailed);
2438       return false;
2439     } else {
2440       bool flush = false;
2441
2442       const size_t argc = args.GetArgumentCount();
2443       if (argc == 0) {
2444         if (m_uuid_option_group.GetOptionValue().OptionWasSet()) {
2445           // We are given a UUID only, go locate the file
2446           ModuleSpec module_spec;
2447           module_spec.GetUUID() =
2448               m_uuid_option_group.GetOptionValue().GetCurrentValue();
2449           if (m_symbol_file.GetOptionValue().OptionWasSet())
2450             module_spec.GetSymbolFileSpec() =
2451                 m_symbol_file.GetOptionValue().GetCurrentValue();
2452           if (Symbols::DownloadObjectAndSymbolFile(module_spec)) {
2453             ModuleSP module_sp(target->GetSharedModule(module_spec));
2454             if (module_sp) {
2455               result.SetStatus(eReturnStatusSuccessFinishResult);
2456               return true;
2457             } else {
2458               StreamString strm;
2459               module_spec.GetUUID().Dump(&strm);
2460               if (module_spec.GetFileSpec()) {
2461                 if (module_spec.GetSymbolFileSpec()) {
2462                   result.AppendErrorWithFormat(
2463                       "Unable to create the executable or symbol file with "
2464                       "UUID %s with path %s and symbol file %s",
2465                       strm.GetData(),
2466                       module_spec.GetFileSpec().GetPath().c_str(),
2467                       module_spec.GetSymbolFileSpec().GetPath().c_str());
2468                 } else {
2469                   result.AppendErrorWithFormat(
2470                       "Unable to create the executable or symbol file with "
2471                       "UUID %s with path %s",
2472                       strm.GetData(),
2473                       module_spec.GetFileSpec().GetPath().c_str());
2474                 }
2475               } else {
2476                 result.AppendErrorWithFormat("Unable to create the executable "
2477                                              "or symbol file with UUID %s",
2478                                              strm.GetData());
2479               }
2480               result.SetStatus(eReturnStatusFailed);
2481               return false;
2482             }
2483           } else {
2484             StreamString strm;
2485             module_spec.GetUUID().Dump(&strm);
2486             result.AppendErrorWithFormat(
2487                 "Unable to locate the executable or symbol file with UUID %s",
2488                 strm.GetData());
2489             result.SetStatus(eReturnStatusFailed);
2490             return false;
2491           }
2492         } else {
2493           result.AppendError(
2494               "one or more executable image paths must be specified");
2495           result.SetStatus(eReturnStatusFailed);
2496           return false;
2497         }
2498       } else {
2499         for (auto &entry : args.entries()) {
2500           if (entry.ref.empty())
2501             continue;
2502
2503           FileSpec file_spec(entry.ref, true);
2504           if (file_spec.Exists()) {
2505             ModuleSpec module_spec(file_spec);
2506             if (m_uuid_option_group.GetOptionValue().OptionWasSet())
2507               module_spec.GetUUID() =
2508                   m_uuid_option_group.GetOptionValue().GetCurrentValue();
2509             if (m_symbol_file.GetOptionValue().OptionWasSet())
2510               module_spec.GetSymbolFileSpec() =
2511                   m_symbol_file.GetOptionValue().GetCurrentValue();
2512             if (!module_spec.GetArchitecture().IsValid())
2513               module_spec.GetArchitecture() = target->GetArchitecture();
2514             Status error;
2515             ModuleSP module_sp(target->GetSharedModule(module_spec, &error));
2516             if (!module_sp) {
2517               const char *error_cstr = error.AsCString();
2518               if (error_cstr)
2519                 result.AppendError(error_cstr);
2520               else
2521                 result.AppendErrorWithFormat("unsupported module: %s",
2522                                              entry.c_str());
2523               result.SetStatus(eReturnStatusFailed);
2524               return false;
2525             } else {
2526               flush = true;
2527             }
2528             result.SetStatus(eReturnStatusSuccessFinishResult);
2529           } else {
2530             std::string resolved_path = file_spec.GetPath();
2531             result.SetStatus(eReturnStatusFailed);
2532             if (resolved_path != entry.ref) {
2533               result.AppendErrorWithFormat(
2534                   "invalid module path '%s' with resolved path '%s'\n",
2535                   entry.ref.str().c_str(), resolved_path.c_str());
2536               break;
2537             }
2538             result.AppendErrorWithFormat("invalid module path '%s'\n",
2539                                          entry.c_str());
2540             break;
2541           }
2542         }
2543       }
2544
2545       if (flush) {
2546         ProcessSP process = target->GetProcessSP();
2547         if (process)
2548           process->Flush();
2549       }
2550     }
2551
2552     return result.Succeeded();
2553   }
2554 };
2555
2556 class CommandObjectTargetModulesLoad
2557     : public CommandObjectTargetModulesModuleAutoComplete {
2558 public:
2559   CommandObjectTargetModulesLoad(CommandInterpreter &interpreter)
2560       : CommandObjectTargetModulesModuleAutoComplete(
2561             interpreter, "target modules load", "Set the load addresses for "
2562                                                 "one or more sections in a "
2563                                                 "target module.",
2564             "target modules load [--file <module> --uuid <uuid>] <sect-name> "
2565             "<address> [<sect-name> <address> ....]"),
2566         m_option_group(),
2567         m_file_option(LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName,
2568                       "Fullpath or basename for module to load.", ""),
2569         m_load_option(LLDB_OPT_SET_1, false, "load", 'l',
2570                       "Write file contents to the memory.", false, true),
2571         m_pc_option(LLDB_OPT_SET_1, false, "set-pc-to-entry", 'p',
2572                     "Set PC to the entry point."
2573                     " Only applicable with '--load' option.",
2574                     false, true),
2575         m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset,
2576                        "Set the load address for all sections to be the "
2577                        "virtual address in the file plus the offset.",
2578                        0) {
2579     m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL,
2580                           LLDB_OPT_SET_1);
2581     m_option_group.Append(&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2582     m_option_group.Append(&m_load_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2583     m_option_group.Append(&m_pc_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2584     m_option_group.Append(&m_slide_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2585     m_option_group.Finalize();
2586   }
2587
2588   ~CommandObjectTargetModulesLoad() override = default;
2589
2590   Options *GetOptions() override { return &m_option_group; }
2591
2592 protected:
2593   bool DoExecute(Args &args, CommandReturnObject &result) override {
2594     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2595     const bool load = m_load_option.GetOptionValue().GetCurrentValue();
2596     const bool set_pc = m_pc_option.GetOptionValue().GetCurrentValue();
2597     if (target == nullptr) {
2598       result.AppendError("invalid target, create a debug target using the "
2599                          "'target create' command");
2600       result.SetStatus(eReturnStatusFailed);
2601       return false;
2602     } else {
2603       const size_t argc = args.GetArgumentCount();
2604       ModuleSpec module_spec;
2605       bool search_using_module_spec = false;
2606
2607       // Allow "load" option to work without --file or --uuid
2608       // option.
2609       if (load) {
2610         if (!m_file_option.GetOptionValue().OptionWasSet() &&
2611             !m_uuid_option_group.GetOptionValue().OptionWasSet()) {
2612           ModuleList &module_list = target->GetImages();
2613           if (module_list.GetSize() == 1) {
2614             search_using_module_spec = true;
2615             module_spec.GetFileSpec() =
2616                 module_list.GetModuleAtIndex(0)->GetFileSpec();
2617           }
2618         }
2619       }
2620
2621       if (m_file_option.GetOptionValue().OptionWasSet()) {
2622         search_using_module_spec = true;
2623         const char *arg_cstr = m_file_option.GetOptionValue().GetCurrentValue();
2624         const bool use_global_module_list = true;
2625         ModuleList module_list;
2626         const size_t num_matches = FindModulesByName(
2627             target, arg_cstr, module_list, use_global_module_list);
2628         if (num_matches == 1) {
2629           module_spec.GetFileSpec() =
2630               module_list.GetModuleAtIndex(0)->GetFileSpec();
2631         } else if (num_matches > 1) {
2632           search_using_module_spec = false;
2633           result.AppendErrorWithFormat(
2634               "more than 1 module matched by name '%s'\n", arg_cstr);
2635           result.SetStatus(eReturnStatusFailed);
2636         } else {
2637           search_using_module_spec = false;
2638           result.AppendErrorWithFormat("no object file for module '%s'\n",
2639                                        arg_cstr);
2640           result.SetStatus(eReturnStatusFailed);
2641         }
2642       }
2643
2644       if (m_uuid_option_group.GetOptionValue().OptionWasSet()) {
2645         search_using_module_spec = true;
2646         module_spec.GetUUID() =
2647             m_uuid_option_group.GetOptionValue().GetCurrentValue();
2648       }
2649
2650       if (search_using_module_spec) {
2651         ModuleList matching_modules;
2652         const size_t num_matches =
2653             target->GetImages().FindModules(module_spec, matching_modules);
2654
2655         char path[PATH_MAX];
2656         if (num_matches == 1) {
2657           Module *module = matching_modules.GetModulePointerAtIndex(0);
2658           if (module) {
2659             ObjectFile *objfile = module->GetObjectFile();
2660             if (objfile) {
2661               SectionList *section_list = module->GetSectionList();
2662               if (section_list) {
2663                 bool changed = false;
2664                 if (argc == 0) {
2665                   if (m_slide_option.GetOptionValue().OptionWasSet()) {
2666                     const addr_t slide =
2667                         m_slide_option.GetOptionValue().GetCurrentValue();
2668                     const bool slide_is_offset = true;
2669                     module->SetLoadAddress(*target, slide, slide_is_offset,
2670                                            changed);
2671                   } else {
2672                     result.AppendError("one or more section name + load "
2673                                        "address pair must be specified");
2674                     result.SetStatus(eReturnStatusFailed);
2675                     return false;
2676                   }
2677                 } else {
2678                   if (m_slide_option.GetOptionValue().OptionWasSet()) {
2679                     result.AppendError("The \"--slide <offset>\" option can't "
2680                                        "be used in conjunction with setting "
2681                                        "section load addresses.\n");
2682                     result.SetStatus(eReturnStatusFailed);
2683                     return false;
2684                   }
2685
2686                   for (size_t i = 0; i < argc; i += 2) {
2687                     const char *sect_name = args.GetArgumentAtIndex(i);
2688                     const char *load_addr_cstr = args.GetArgumentAtIndex(i + 1);
2689                     if (sect_name && load_addr_cstr) {
2690                       ConstString const_sect_name(sect_name);
2691                       bool success = false;
2692                       addr_t load_addr = StringConvert::ToUInt64(
2693                           load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
2694                       if (success) {
2695                         SectionSP section_sp(
2696                             section_list->FindSectionByName(const_sect_name));
2697                         if (section_sp) {
2698                           if (section_sp->IsThreadSpecific()) {
2699                             result.AppendErrorWithFormat(
2700                                 "thread specific sections are not yet "
2701                                 "supported (section '%s')\n",
2702                                 sect_name);
2703                             result.SetStatus(eReturnStatusFailed);
2704                             break;
2705                           } else {
2706                             if (target->GetSectionLoadList()
2707                                     .SetSectionLoadAddress(section_sp,
2708                                                            load_addr))
2709                               changed = true;
2710                             result.AppendMessageWithFormat(
2711                                 "section '%s' loaded at 0x%" PRIx64 "\n",
2712                                 sect_name, load_addr);
2713                           }
2714                         } else {
2715                           result.AppendErrorWithFormat("no section found that "
2716                                                        "matches the section "
2717                                                        "name '%s'\n",
2718                                                        sect_name);
2719                           result.SetStatus(eReturnStatusFailed);
2720                           break;
2721                         }
2722                       } else {
2723                         result.AppendErrorWithFormat(
2724                             "invalid load address string '%s'\n",
2725                             load_addr_cstr);
2726                         result.SetStatus(eReturnStatusFailed);
2727                         break;
2728                       }
2729                     } else {
2730                       if (sect_name)
2731                         result.AppendError("section names must be followed by "
2732                                            "a load address.\n");
2733                       else
2734                         result.AppendError("one or more section name + load "
2735                                            "address pair must be specified.\n");
2736                       result.SetStatus(eReturnStatusFailed);
2737                       break;
2738                     }
2739                   }
2740                 }
2741
2742                 if (changed) {
2743                   target->ModulesDidLoad(matching_modules);
2744                   Process *process = m_exe_ctx.GetProcessPtr();
2745                   if (process)
2746                     process->Flush();
2747                 }
2748                 if (load) {
2749                   Status error = module->LoadInMemory(*target, set_pc);
2750                   if (error.Fail()) {
2751                     result.AppendError(error.AsCString());
2752                     return false;
2753                   }
2754                 }
2755               } else {
2756                 module->GetFileSpec().GetPath(path, sizeof(path));
2757                 result.AppendErrorWithFormat(
2758                     "no sections in object file '%s'\n", path);
2759                 result.SetStatus(eReturnStatusFailed);
2760               }
2761             } else {
2762               module->GetFileSpec().GetPath(path, sizeof(path));
2763               result.AppendErrorWithFormat("no object file for module '%s'\n",
2764                                            path);
2765               result.SetStatus(eReturnStatusFailed);
2766             }
2767           } else {
2768             FileSpec *module_spec_file = module_spec.GetFileSpecPtr();
2769             if (module_spec_file) {
2770               module_spec_file->GetPath(path, sizeof(path));
2771               result.AppendErrorWithFormat("invalid module '%s'.\n", path);
2772             } else
2773               result.AppendError("no module spec");
2774             result.SetStatus(eReturnStatusFailed);
2775           }
2776         } else {
2777           std::string uuid_str;
2778
2779           if (module_spec.GetFileSpec())
2780             module_spec.GetFileSpec().GetPath(path, sizeof(path));
2781           else
2782             path[0] = '\0';
2783
2784           if (module_spec.GetUUIDPtr())
2785             uuid_str = module_spec.GetUUID().GetAsString();
2786           if (num_matches > 1) {
2787             result.AppendErrorWithFormat(
2788                 "multiple modules match%s%s%s%s:\n", path[0] ? " file=" : "",
2789                 path, !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str());
2790             for (size_t i = 0; i < num_matches; ++i) {
2791               if (matching_modules.GetModulePointerAtIndex(i)
2792                       ->GetFileSpec()
2793                       .GetPath(path, sizeof(path)))
2794                 result.AppendMessageWithFormat("%s\n", path);
2795             }
2796           } else {
2797             result.AppendErrorWithFormat(
2798                 "no modules were found  that match%s%s%s%s.\n",
2799                 path[0] ? " file=" : "", path,
2800                 !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str());
2801           }
2802           result.SetStatus(eReturnStatusFailed);
2803         }
2804       } else {
2805         result.AppendError("either the \"--file <module>\" or the \"--uuid "
2806                            "<uuid>\" option must be specified.\n");
2807         result.SetStatus(eReturnStatusFailed);
2808         return false;
2809       }
2810     }
2811     return result.Succeeded();
2812   }
2813
2814   OptionGroupOptions m_option_group;
2815   OptionGroupUUID m_uuid_option_group;
2816   OptionGroupString m_file_option;
2817   OptionGroupBoolean m_load_option;
2818   OptionGroupBoolean m_pc_option;
2819   OptionGroupUInt64 m_slide_option;
2820 };
2821
2822 //----------------------------------------------------------------------
2823 // List images with associated information
2824 //----------------------------------------------------------------------
2825
2826 static OptionDefinition g_target_modules_list_options[] = {
2827     // clang-format off
2828   { LLDB_OPT_SET_1, false, "address",        'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Display the image at this address." },
2829   { LLDB_OPT_SET_1, false, "arch",           'A', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the architecture when listing images." },
2830   { LLDB_OPT_SET_1, false, "triple",         't', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the triple when listing images." },
2831   { LLDB_OPT_SET_1, false, "header",         'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the image header address as a load address if debugging, a file address otherwise." },
2832   { LLDB_OPT_SET_1, false, "offset",         'o', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the image header address offset from the header file address (the slide amount)." },
2833   { LLDB_OPT_SET_1, false, "uuid",           'u', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the UUID when listing images." },
2834   { LLDB_OPT_SET_1, false, "fullpath",       'f', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the fullpath to the image object file." },
2835   { LLDB_OPT_SET_1, false, "directory",      'd', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the directory with optional width for the image object file." },
2836   { LLDB_OPT_SET_1, false, "basename",       'b', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the basename with optional width for the image object file." },
2837   { LLDB_OPT_SET_1, false, "symfile",        's', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the fullpath to the image symbol file with optional width." },
2838   { LLDB_OPT_SET_1, false, "symfile-unique", 'S', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the symbol file with optional width only if it is different from the executable object file." },
2839   { LLDB_OPT_SET_1, false, "mod-time",       'm', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the modification time with optional width of the module." },
2840   { LLDB_OPT_SET_1, false, "ref-count",      'r', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the reference count if the module is still in the shared module cache." },
2841   { LLDB_OPT_SET_1, false, "pointer",        'p', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeNone,                "Display the module pointer." },
2842   { LLDB_OPT_SET_1, false, "global",         'g', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the modules from the global module list, not just the current target." }
2843     // clang-format on
2844 };
2845
2846 class CommandObjectTargetModulesList : public CommandObjectParsed {
2847 public:
2848   class CommandOptions : public Options {
2849   public:
2850     CommandOptions()
2851         : Options(), m_format_array(), m_use_global_module_list(false),
2852           m_module_addr(LLDB_INVALID_ADDRESS) {}
2853
2854     ~CommandOptions() override = default;
2855
2856     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2857                           ExecutionContext *execution_context) override {
2858       Status error;
2859
2860       const int short_option = m_getopt_table[option_idx].val;
2861       if (short_option == 'g') {
2862         m_use_global_module_list = true;
2863       } else if (short_option == 'a') {
2864         m_module_addr = Args::StringToAddress(execution_context, option_arg,
2865                                               LLDB_INVALID_ADDRESS, &error);
2866       } else {
2867         unsigned long width = 0;
2868         option_arg.getAsInteger(0, width);
2869         m_format_array.push_back(std::make_pair(short_option, width));
2870       }
2871       return error;
2872     }
2873
2874     void OptionParsingStarting(ExecutionContext *execution_context) override {
2875       m_format_array.clear();
2876       m_use_global_module_list = false;
2877       m_module_addr = LLDB_INVALID_ADDRESS;
2878     }
2879
2880     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2881       return llvm::makeArrayRef(g_target_modules_list_options);
2882     }
2883
2884     // Instance variables to hold the values for command options.
2885     typedef std::vector<std::pair<char, uint32_t>> FormatWidthCollection;
2886     FormatWidthCollection m_format_array;
2887     bool m_use_global_module_list;
2888     lldb::addr_t m_module_addr;
2889   };
2890
2891   CommandObjectTargetModulesList(CommandInterpreter &interpreter)
2892       : CommandObjectParsed(
2893             interpreter, "target modules list",
2894             "List current executable and dependent shared library images.",
2895             "target modules list [<cmd-options>]"),
2896         m_options() {}
2897
2898   ~CommandObjectTargetModulesList() override = default;
2899
2900   Options *GetOptions() override { return &m_options; }
2901
2902 protected:
2903   bool DoExecute(Args &command, CommandReturnObject &result) override {
2904     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2905     const bool use_global_module_list = m_options.m_use_global_module_list;
2906     // Define a local module list here to ensure it lives longer than any
2907     // "locker"
2908     // object which might lock its contents below (through the "module_list_ptr"
2909     // variable).
2910     ModuleList module_list;
2911     if (target == nullptr && !use_global_module_list) {
2912       result.AppendError("invalid target, create a debug target using the "
2913                          "'target create' command");
2914       result.SetStatus(eReturnStatusFailed);
2915       return false;
2916     } else {
2917       if (target) {
2918         uint32_t addr_byte_size =
2919             target->GetArchitecture().GetAddressByteSize();
2920         result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2921         result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2922       }
2923       // Dump all sections for all modules images
2924       Stream &strm = result.GetOutputStream();
2925
2926       if (m_options.m_module_addr != LLDB_INVALID_ADDRESS) {
2927         if (target) {
2928           Address module_address;
2929           if (module_address.SetLoadAddress(m_options.m_module_addr, target)) {
2930             ModuleSP module_sp(module_address.GetModule());
2931             if (module_sp) {
2932               PrintModule(target, module_sp.get(), 0, strm);
2933               result.SetStatus(eReturnStatusSuccessFinishResult);
2934             } else {
2935               result.AppendErrorWithFormat(
2936                   "Couldn't find module matching address: 0x%" PRIx64 ".",
2937                   m_options.m_module_addr);
2938               result.SetStatus(eReturnStatusFailed);
2939             }
2940           } else {
2941             result.AppendErrorWithFormat(
2942                 "Couldn't find module containing address: 0x%" PRIx64 ".",
2943                 m_options.m_module_addr);
2944             result.SetStatus(eReturnStatusFailed);
2945           }
2946         } else {
2947           result.AppendError(
2948               "Can only look up modules by address with a valid target.");
2949           result.SetStatus(eReturnStatusFailed);
2950         }
2951         return result.Succeeded();
2952       }
2953
2954       size_t num_modules = 0;
2955
2956       // This locker will be locked on the mutex in module_list_ptr if it is
2957       // non-nullptr.
2958       // Otherwise it will lock the AllocationModuleCollectionMutex when
2959       // accessing
2960       // the global module list directly.
2961       std::unique_lock<std::recursive_mutex> guard(
2962           Module::GetAllocationModuleCollectionMutex(), std::defer_lock);
2963
2964       const ModuleList *module_list_ptr = nullptr;
2965       const size_t argc = command.GetArgumentCount();
2966       if (argc == 0) {
2967         if (use_global_module_list) {
2968           guard.lock();
2969           num_modules = Module::GetNumberAllocatedModules();
2970         } else {
2971           module_list_ptr = &target->GetImages();
2972         }
2973       } else {
2974         // TODO: Convert to entry based iteration.  Requires converting
2975         // FindModulesByName.
2976         for (size_t i = 0; i < argc; ++i) {
2977           // Dump specified images (by basename or fullpath)
2978           const char *arg_cstr = command.GetArgumentAtIndex(i);
2979           const size_t num_matches = FindModulesByName(
2980               target, arg_cstr, module_list, use_global_module_list);
2981           if (num_matches == 0) {
2982             if (argc == 1) {
2983               result.AppendErrorWithFormat("no modules found that match '%s'",
2984                                            arg_cstr);
2985               result.SetStatus(eReturnStatusFailed);
2986               return false;
2987             }
2988           }
2989         }
2990
2991         module_list_ptr = &module_list;
2992       }
2993
2994       std::unique_lock<std::recursive_mutex> lock;
2995       if (module_list_ptr != nullptr) {
2996         lock =
2997             std::unique_lock<std::recursive_mutex>(module_list_ptr->GetMutex());
2998
2999         num_modules = module_list_ptr->GetSize();
3000       }
3001
3002       if (num_modules > 0) {
3003         for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) {
3004           ModuleSP module_sp;
3005           Module *module;
3006           if (module_list_ptr) {
3007             module_sp = module_list_ptr->GetModuleAtIndexUnlocked(image_idx);
3008             module = module_sp.get();
3009           } else {
3010             module = Module::GetAllocatedModuleAtIndex(image_idx);
3011             module_sp = module->shared_from_this();
3012           }
3013
3014           const size_t indent = strm.Printf("[%3u] ", image_idx);
3015           PrintModule(target, module, indent, strm);
3016         }
3017         result.SetStatus(eReturnStatusSuccessFinishResult);
3018       } else {
3019         if (argc) {
3020           if (use_global_module_list)
3021             result.AppendError(
3022                 "the global module list has no matching modules");
3023           else
3024             result.AppendError("the target has no matching modules");
3025         } else {
3026           if (use_global_module_list)
3027             result.AppendError("the global module list is empty");
3028           else
3029             result.AppendError(
3030                 "the target has no associated executable images");
3031         }
3032         result.SetStatus(eReturnStatusFailed);
3033         return false;
3034       }
3035     }
3036     return result.Succeeded();
3037   }
3038
3039   void PrintModule(Target *target, Module *module, int indent, Stream &strm) {
3040     if (module == nullptr) {
3041       strm.PutCString("Null module");
3042       return;
3043     }
3044
3045     bool dump_object_name = false;
3046     if (m_options.m_format_array.empty()) {
3047       m_options.m_format_array.push_back(std::make_pair('u', 0));
3048       m_options.m_format_array.push_back(std::make_pair('h', 0));
3049       m_options.m_format_array.push_back(std::make_pair('f', 0));
3050       m_options.m_format_array.push_back(std::make_pair('S', 0));
3051     }
3052     const size_t num_entries = m_options.m_format_array.size();
3053     bool print_space = false;
3054     for (size_t i = 0; i < num_entries; ++i) {
3055       if (print_space)
3056         strm.PutChar(' ');
3057       print_space = true;
3058       const char format_char = m_options.m_format_array[i].first;
3059       uint32_t width = m_options.m_format_array[i].second;
3060       switch (format_char) {
3061       case 'A':
3062         DumpModuleArchitecture(strm, module, false, width);
3063         break;
3064
3065       case 't':
3066         DumpModuleArchitecture(strm, module, true, width);
3067         break;
3068
3069       case 'f':
3070         DumpFullpath(strm, &module->GetFileSpec(), width);
3071         dump_object_name = true;
3072         break;
3073
3074       case 'd':
3075         DumpDirectory(strm, &module->GetFileSpec(), width);
3076         break;
3077
3078       case 'b':
3079         DumpBasename(strm, &module->GetFileSpec(), width);
3080         dump_object_name = true;
3081         break;
3082
3083       case 'h':
3084       case 'o':
3085         // Image header address
3086         {
3087           uint32_t addr_nibble_width =
3088               target ? (target->GetArchitecture().GetAddressByteSize() * 2)
3089                      : 16;
3090
3091           ObjectFile *objfile = module->GetObjectFile();
3092           if (objfile) {
3093             Address header_addr(objfile->GetHeaderAddress());
3094             if (header_addr.IsValid()) {
3095               if (target && !target->GetSectionLoadList().IsEmpty()) {
3096                 lldb::addr_t header_load_addr =
3097                     header_addr.GetLoadAddress(target);
3098                 if (header_load_addr == LLDB_INVALID_ADDRESS) {
3099                   header_addr.Dump(&strm, target,
3100                                    Address::DumpStyleModuleWithFileAddress,
3101                                    Address::DumpStyleFileAddress);
3102                 } else {
3103                   if (format_char == 'o') {
3104                     // Show the offset of slide for the image
3105                     strm.Printf(
3106                         "0x%*.*" PRIx64, addr_nibble_width, addr_nibble_width,
3107                         header_load_addr - header_addr.GetFileAddress());
3108                   } else {
3109                     // Show the load address of the image
3110                     strm.Printf("0x%*.*" PRIx64, addr_nibble_width,
3111                                 addr_nibble_width, header_load_addr);
3112                   }
3113                 }
3114                 break;
3115               }
3116               // The address was valid, but the image isn't loaded, output the
3117               // address in an appropriate format
3118               header_addr.Dump(&strm, target, Address::DumpStyleFileAddress);
3119               break;
3120             }
3121           }
3122           strm.Printf("%*s", addr_nibble_width + 2, "");
3123         }
3124         break;
3125
3126       case 'r': {
3127         size_t ref_count = 0;
3128         ModuleSP module_sp(module->shared_from_this());
3129         if (module_sp) {
3130           // Take one away to make sure we don't count our local "module_sp"
3131           ref_count = module_sp.use_count() - 1;
3132         }
3133         if (width)
3134           strm.Printf("{%*" PRIu64 "}", width, (uint64_t)ref_count);
3135         else
3136           strm.Printf("{%" PRIu64 "}", (uint64_t)ref_count);
3137       } break;
3138
3139       case 's':
3140       case 'S': {
3141         const SymbolVendor *symbol_vendor = module->GetSymbolVendor();
3142         if (symbol_vendor) {
3143           const FileSpec symfile_spec = symbol_vendor->GetMainFileSpec();
3144           if (format_char == 'S') {
3145             // Dump symbol file only if different from module file
3146             if (!symfile_spec || symfile_spec == module->GetFileSpec()) {
3147               print_space = false;
3148               break;
3149             }
3150             // Add a newline and indent past the index
3151             strm.Printf("\n%*s", indent, "");
3152           }
3153           DumpFullpath(strm, &symfile_spec, width);
3154           dump_object_name = true;
3155           break;
3156         }
3157         strm.Printf("%.*s", width, "<NONE>");
3158       } break;
3159
3160       case 'm':
3161         strm.Format("{0:%c}", llvm::fmt_align(module->GetModificationTime(),
3162                                               llvm::AlignStyle::Left, width));
3163         break;
3164
3165       case 'p':
3166         strm.Printf("%p", static_cast<void *>(module));
3167         break;
3168
3169       case 'u':
3170         DumpModuleUUID(strm, module);
3171         break;
3172
3173       default:
3174         break;
3175       }
3176     }
3177     if (dump_object_name) {
3178       const char *object_name = module->GetObjectName().GetCString();
3179       if (object_name)
3180         strm.Printf("(%s)", object_name);
3181     }
3182     strm.EOL();
3183   }
3184
3185   CommandOptions m_options;
3186 };
3187
3188 #pragma mark CommandObjectTargetModulesShowUnwind
3189
3190 //----------------------------------------------------------------------
3191 // Lookup unwind information in images
3192 //----------------------------------------------------------------------
3193
3194 static OptionDefinition g_target_modules_show_unwind_options[] = {
3195     // clang-format off
3196   { LLDB_OPT_SET_1, false, "name",    'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionName,        "Show unwind instructions for a function or symbol name." },
3197   { LLDB_OPT_SET_2, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Show unwind instructions for a function or symbol containing an address" }
3198     // clang-format on
3199 };
3200
3201 class CommandObjectTargetModulesShowUnwind : public CommandObjectParsed {
3202 public:
3203   enum {
3204     eLookupTypeInvalid = -1,
3205     eLookupTypeAddress = 0,
3206     eLookupTypeSymbol,
3207     eLookupTypeFunction,
3208     eLookupTypeFunctionOrSymbol,
3209     kNumLookupTypes
3210   };
3211
3212   class CommandOptions : public Options {
3213   public:
3214     CommandOptions()
3215         : Options(), m_type(eLookupTypeInvalid), m_str(),
3216           m_addr(LLDB_INVALID_ADDRESS) {}
3217
3218     ~CommandOptions() override = default;
3219
3220     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
3221                           ExecutionContext *execution_context) override {
3222       Status error;
3223
3224       const int short_option = m_getopt_table[option_idx].val;
3225
3226       switch (short_option) {
3227       case 'a': {
3228         m_str = option_arg;
3229         m_type = eLookupTypeAddress;
3230         m_addr = Args::StringToAddress(execution_context, option_arg,
3231                                        LLDB_INVALID_ADDRESS, &error);
3232         if (m_addr == LLDB_INVALID_ADDRESS)
3233           error.SetErrorStringWithFormat("invalid address string '%s'",
3234                                          option_arg.str().c_str());
3235         break;
3236       }
3237
3238       case 'n':
3239         m_str = option_arg;
3240         m_type = eLookupTypeFunctionOrSymbol;
3241         break;
3242
3243       default:
3244         error.SetErrorStringWithFormat("unrecognized option %c.", short_option);
3245         break;
3246       }
3247
3248       return error;
3249     }
3250
3251     void OptionParsingStarting(ExecutionContext *execution_context) override {
3252       m_type = eLookupTypeInvalid;
3253       m_str.clear();
3254       m_addr = LLDB_INVALID_ADDRESS;
3255     }
3256
3257     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
3258       return llvm::makeArrayRef(g_target_modules_show_unwind_options);
3259     }
3260
3261     // Instance variables to hold the values for command options.
3262
3263     int m_type;        // Should be a eLookupTypeXXX enum after parsing options
3264     std::string m_str; // Holds name lookup
3265     lldb::addr_t m_addr; // Holds the address to lookup
3266   };
3267
3268   CommandObjectTargetModulesShowUnwind(CommandInterpreter &interpreter)
3269       : CommandObjectParsed(
3270             interpreter, "target modules show-unwind",
3271             "Show synthesized unwind instructions for a function.", nullptr,
3272             eCommandRequiresTarget | eCommandRequiresProcess |
3273                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
3274         m_options() {}
3275
3276   ~CommandObjectTargetModulesShowUnwind() override = default;
3277
3278   Options *GetOptions() override { return &m_options; }
3279
3280 protected:
3281   bool DoExecute(Args &command, CommandReturnObject &result) override {
3282     Target *target = m_exe_ctx.GetTargetPtr();
3283     Process *process = m_exe_ctx.GetProcessPtr();
3284     ABI *abi = nullptr;
3285     if (process)
3286       abi = process->GetABI().get();
3287
3288     if (process == nullptr) {
3289       result.AppendError(
3290           "You must have a process running to use this command.");
3291       result.SetStatus(eReturnStatusFailed);
3292       return false;
3293     }
3294
3295     ThreadList threads(process->GetThreadList());
3296     if (threads.GetSize() == 0) {
3297       result.AppendError("The process must be paused to use this command.");
3298       result.SetStatus(eReturnStatusFailed);
3299       return false;
3300     }
3301
3302     ThreadSP thread(threads.GetThreadAtIndex(0));
3303     if (!thread) {
3304       result.AppendError("The process must be paused to use this command.");
3305       result.SetStatus(eReturnStatusFailed);
3306       return false;
3307     }
3308
3309     SymbolContextList sc_list;
3310
3311     if (m_options.m_type == eLookupTypeFunctionOrSymbol) {
3312       ConstString function_name(m_options.m_str.c_str());
3313       target->GetImages().FindFunctions(function_name, eFunctionNameTypeAuto,
3314                                         true, false, true, sc_list);
3315     } else if (m_options.m_type == eLookupTypeAddress && target) {
3316       Address addr;
3317       if (target->GetSectionLoadList().ResolveLoadAddress(m_options.m_addr,
3318                                                           addr)) {
3319         SymbolContext sc;
3320         ModuleSP module_sp(addr.GetModule());
3321         module_sp->ResolveSymbolContextForAddress(addr,
3322                                                   eSymbolContextEverything, sc);
3323         if (sc.function || sc.symbol) {
3324           sc_list.Append(sc);
3325         }
3326       }
3327     } else {
3328       result.AppendError(
3329           "address-expression or function name option must be specified.");
3330       result.SetStatus(eReturnStatusFailed);
3331       return false;
3332     }
3333
3334     size_t num_matches = sc_list.GetSize();
3335     if (num_matches == 0) {
3336       result.AppendErrorWithFormat("no unwind data found that matches '%s'.",
3337                                    m_options.m_str.c_str());
3338       result.SetStatus(eReturnStatusFailed);
3339       return false;
3340     }
3341
3342     for (uint32_t idx = 0; idx < num_matches; idx++) {
3343       SymbolContext sc;
3344       sc_list.GetContextAtIndex(idx, sc);
3345       if (sc.symbol == nullptr && sc.function == nullptr)
3346         continue;
3347       if (!sc.module_sp || sc.module_sp->GetObjectFile() == nullptr)
3348         continue;
3349       AddressRange range;
3350       if (!sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
3351                               false, range))
3352         continue;
3353       if (!range.GetBaseAddress().IsValid())
3354         continue;
3355       ConstString funcname(sc.GetFunctionName());
3356       if (funcname.IsEmpty())
3357         continue;
3358       addr_t start_addr = range.GetBaseAddress().GetLoadAddress(target);
3359       if (abi)
3360         start_addr = abi->FixCodeAddress(start_addr);
3361
3362       FuncUnwindersSP func_unwinders_sp(
3363           sc.module_sp->GetObjectFile()
3364               ->GetUnwindTable()
3365               .GetUncachedFuncUnwindersContainingAddress(start_addr, sc));
3366       if (!func_unwinders_sp)
3367         continue;
3368
3369       result.GetOutputStream().Printf(
3370           "UNWIND PLANS for %s`%s (start addr 0x%" PRIx64 ")\n\n",
3371           sc.module_sp->GetPlatformFileSpec().GetFilename().AsCString(),
3372           funcname.AsCString(), start_addr);
3373
3374       UnwindPlanSP non_callsite_unwind_plan =
3375           func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread, -1);
3376       if (non_callsite_unwind_plan) {
3377         result.GetOutputStream().Printf(
3378             "Asynchronous (not restricted to call-sites) UnwindPlan is '%s'\n",
3379             non_callsite_unwind_plan->GetSourceName().AsCString());
3380       }
3381       UnwindPlanSP callsite_unwind_plan =
3382           func_unwinders_sp->GetUnwindPlanAtCallSite(*target, -1);
3383       if (callsite_unwind_plan) {
3384         result.GetOutputStream().Printf(
3385             "Synchronous (restricted to call-sites) UnwindPlan is '%s'\n",
3386             callsite_unwind_plan->GetSourceName().AsCString());
3387       }
3388       UnwindPlanSP fast_unwind_plan =
3389           func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread);
3390       if (fast_unwind_plan) {
3391         result.GetOutputStream().Printf(
3392             "Fast UnwindPlan is '%s'\n",
3393             fast_unwind_plan->GetSourceName().AsCString());
3394       }
3395
3396       result.GetOutputStream().Printf("\n");
3397
3398       UnwindPlanSP assembly_sp =
3399           func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread, 0);
3400       if (assembly_sp) {
3401         result.GetOutputStream().Printf(
3402             "Assembly language inspection UnwindPlan:\n");
3403         assembly_sp->Dump(result.GetOutputStream(), thread.get(),
3404                           LLDB_INVALID_ADDRESS);
3405         result.GetOutputStream().Printf("\n");
3406       }
3407
3408       UnwindPlanSP ehframe_sp =
3409           func_unwinders_sp->GetEHFrameUnwindPlan(*target, 0);
3410       if (ehframe_sp) {
3411         result.GetOutputStream().Printf("eh_frame UnwindPlan:\n");
3412         ehframe_sp->Dump(result.GetOutputStream(), thread.get(),
3413                          LLDB_INVALID_ADDRESS);
3414         result.GetOutputStream().Printf("\n");
3415       }
3416
3417       UnwindPlanSP ehframe_augmented_sp =
3418           func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread, 0);
3419       if (ehframe_augmented_sp) {
3420         result.GetOutputStream().Printf("eh_frame augmented UnwindPlan:\n");
3421         ehframe_augmented_sp->Dump(result.GetOutputStream(), thread.get(),
3422                                    LLDB_INVALID_ADDRESS);
3423         result.GetOutputStream().Printf("\n");
3424       }
3425
3426       if (UnwindPlanSP plan_sp =
3427               func_unwinders_sp->GetDebugFrameUnwindPlan(*target, 0)) {
3428         result.GetOutputStream().Printf("debug_frame UnwindPlan:\n");
3429         plan_sp->Dump(result.GetOutputStream(), thread.get(),
3430                       LLDB_INVALID_ADDRESS);
3431         result.GetOutputStream().Printf("\n");
3432       }
3433
3434       if (UnwindPlanSP plan_sp =
3435               func_unwinders_sp->GetDebugFrameAugmentedUnwindPlan(*target,
3436                                                                   *thread, 0)) {
3437         result.GetOutputStream().Printf("debug_frame augmented UnwindPlan:\n");
3438         plan_sp->Dump(result.GetOutputStream(), thread.get(),
3439                       LLDB_INVALID_ADDRESS);
3440         result.GetOutputStream().Printf("\n");
3441       }
3442
3443       UnwindPlanSP arm_unwind_sp =
3444           func_unwinders_sp->GetArmUnwindUnwindPlan(*target, 0);
3445       if (arm_unwind_sp) {
3446         result.GetOutputStream().Printf("ARM.exidx unwind UnwindPlan:\n");
3447         arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
3448                             LLDB_INVALID_ADDRESS);
3449         result.GetOutputStream().Printf("\n");
3450       }
3451
3452       UnwindPlanSP compact_unwind_sp =
3453           func_unwinders_sp->GetCompactUnwindUnwindPlan(*target, 0);
3454       if (compact_unwind_sp) {
3455         result.GetOutputStream().Printf("Compact unwind UnwindPlan:\n");
3456         compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
3457                                 LLDB_INVALID_ADDRESS);
3458         result.GetOutputStream().Printf("\n");
3459       }
3460
3461       if (fast_unwind_plan) {
3462         result.GetOutputStream().Printf("Fast UnwindPlan:\n");
3463         fast_unwind_plan->Dump(result.GetOutputStream(), thread.get(),
3464                                LLDB_INVALID_ADDRESS);
3465         result.GetOutputStream().Printf("\n");
3466       }
3467
3468       ABISP abi_sp = process->GetABI();
3469       if (abi_sp) {
3470         UnwindPlan arch_default(lldb::eRegisterKindGeneric);
3471         if (abi_sp->CreateDefaultUnwindPlan(arch_default)) {
3472           result.GetOutputStream().Printf("Arch default UnwindPlan:\n");
3473           arch_default.Dump(result.GetOutputStream(), thread.get(),
3474                             LLDB_INVALID_ADDRESS);
3475           result.GetOutputStream().Printf("\n");
3476         }
3477
3478         UnwindPlan arch_entry(lldb::eRegisterKindGeneric);
3479         if (abi_sp->CreateFunctionEntryUnwindPlan(arch_entry)) {
3480           result.GetOutputStream().Printf(
3481               "Arch default at entry point UnwindPlan:\n");
3482           arch_entry.Dump(result.GetOutputStream(), thread.get(),
3483                           LLDB_INVALID_ADDRESS);
3484           result.GetOutputStream().Printf("\n");
3485         }
3486       }
3487
3488       result.GetOutputStream().Printf("\n");
3489     }
3490     return result.Succeeded();
3491   }
3492
3493   CommandOptions m_options;
3494 };
3495
3496 //----------------------------------------------------------------------
3497 // Lookup information in images
3498 //----------------------------------------------------------------------
3499
3500 static OptionDefinition g_target_modules_lookup_options[] = {
3501     // clang-format off
3502   { LLDB_OPT_SET_1,                                  true,  "address",    'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Lookup an address in one or more target modules." },
3503   { LLDB_OPT_SET_1,                                  false, "offset",     'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset,              "When looking up an address subtract <offset> from any addresses before doing the lookup." },
3504   /* FIXME: re-enable regex for types when the LookupTypeInModule actually uses the regex option: | LLDB_OPT_SET_6 */
3505   { LLDB_OPT_SET_2 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5, false, "regex",      'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "The <name> argument for name lookups are regular expressions." },
3506   { LLDB_OPT_SET_2,                                  true,  "symbol",     's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSymbol,              "Lookup a symbol by name in the symbol tables in one or more target modules." },
3507   { LLDB_OPT_SET_3,                                  true,  "file",       'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename,            "Lookup a file by fullpath or basename in one or more target modules." },
3508   { LLDB_OPT_SET_3,                                  false, "line",       'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,             "Lookup a line number in a file (must be used in conjunction with --file)." },
3509   { LLDB_OPT_SET_FROM_TO(3,5),                       false, "no-inlines", 'i', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Ignore inline entries (must be used in conjunction with --file or --function)." },
3510   { LLDB_OPT_SET_4,                                  true,  "function",   'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionName,        "Lookup a function by name in the debug symbols in one or more target modules." },
3511   { LLDB_OPT_SET_5,                                  true,  "name",       'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionOrSymbol,    "Lookup a function or symbol by name in one or more target modules." },
3512   { LLDB_OPT_SET_6,                                  true,  "type",       't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,                "Lookup a type by name in the debug symbols in one or more target modules." },
3513   { LLDB_OPT_SET_ALL,                                false, "verbose",    'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Enable verbose lookup information." },
3514   { LLDB_OPT_SET_ALL,                                false, "all",        'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Print all matches, not just the best match, if a best match is available." },
3515     // clang-format on
3516 };
3517
3518 class CommandObjectTargetModulesLookup : public CommandObjectParsed {
3519 public:
3520   enum {
3521     eLookupTypeInvalid = -1,
3522     eLookupTypeAddress = 0,
3523     eLookupTypeSymbol,
3524     eLookupTypeFileLine, // Line is optional
3525     eLookupTypeFunction,
3526     eLookupTypeFunctionOrSymbol,
3527     eLookupTypeType,
3528     kNumLookupTypes
3529   };
3530
3531   class CommandOptions : public Options {
3532   public:
3533     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
3534
3535     ~CommandOptions() override = default;
3536
3537     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
3538                           ExecutionContext *execution_context) override {
3539       Status error;
3540
3541       const int short_option = m_getopt_table[option_idx].val;
3542
3543       switch (short_option) {
3544       case 'a': {
3545         m_type = eLookupTypeAddress;
3546         m_addr = Args::StringToAddress(execution_context, option_arg,
3547                                        LLDB_INVALID_ADDRESS, &error);
3548       } break;
3549
3550       case 'o':
3551         if (option_arg.getAsInteger(0, m_offset))
3552           error.SetErrorStringWithFormat("invalid offset string '%s'",
3553                                          option_arg.str().c_str());
3554         break;
3555
3556       case 's':
3557         m_str = option_arg;
3558         m_type = eLookupTypeSymbol;
3559         break;
3560
3561       case 'f':
3562         m_file.SetFile(option_arg, false);
3563         m_type = eLookupTypeFileLine;
3564         break;
3565
3566       case 'i':
3567         m_include_inlines = false;
3568         break;
3569
3570       case 'l':
3571         if (option_arg.getAsInteger(0, m_line_number))
3572           error.SetErrorStringWithFormat("invalid line number string '%s'",
3573                                          option_arg.str().c_str());
3574         else if (m_line_number == 0)
3575           error.SetErrorString("zero is an invalid line number");
3576         m_type = eLookupTypeFileLine;
3577         break;
3578
3579       case 'F':
3580         m_str = option_arg;
3581         m_type = eLookupTypeFunction;
3582         break;
3583
3584       case 'n':
3585         m_str = option_arg;
3586         m_type = eLookupTypeFunctionOrSymbol;
3587         break;
3588
3589       case 't':
3590         m_str = option_arg;
3591         m_type = eLookupTypeType;
3592         break;
3593
3594       case 'v':
3595         m_verbose = 1;
3596         break;
3597
3598       case 'A':
3599         m_print_all = true;
3600         break;
3601
3602       case 'r':
3603         m_use_regex = true;
3604         break;
3605       }
3606
3607       return error;
3608     }
3609
3610     void OptionParsingStarting(ExecutionContext *execution_context) override {
3611       m_type = eLookupTypeInvalid;
3612       m_str.clear();
3613       m_file.Clear();
3614       m_addr = LLDB_INVALID_ADDRESS;
3615       m_offset = 0;
3616       m_line_number = 0;
3617       m_use_regex = false;
3618       m_include_inlines = true;
3619       m_verbose = false;
3620       m_print_all = false;
3621     }
3622
3623     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
3624       return llvm::makeArrayRef(g_target_modules_lookup_options);
3625     }
3626
3627     int m_type;        // Should be a eLookupTypeXXX enum after parsing options
3628     std::string m_str; // Holds name lookup
3629     FileSpec m_file;   // Files for file lookups
3630     lldb::addr_t m_addr; // Holds the address to lookup
3631     lldb::addr_t
3632         m_offset; // Subtract this offset from m_addr before doing lookups.
3633     uint32_t m_line_number; // Line number for file+line lookups
3634     bool m_use_regex;       // Name lookups in m_str are regular expressions.
3635     bool m_include_inlines; // Check for inline entries when looking up by
3636                             // file/line.
3637     bool m_verbose;         // Enable verbose lookup info
3638     bool m_print_all; // Print all matches, even in cases where there's a best
3639                       // match.
3640   };
3641
3642   CommandObjectTargetModulesLookup(CommandInterpreter &interpreter)
3643       : CommandObjectParsed(interpreter, "target modules lookup",
3644                             "Look up information within executable and "
3645                             "dependent shared library images.",
3646                             nullptr, eCommandRequiresTarget),
3647         m_options() {
3648     CommandArgumentEntry arg;
3649     CommandArgumentData file_arg;
3650
3651     // Define the first (and only) variant of this arg.
3652     file_arg.arg_type = eArgTypeFilename;
3653     file_arg.arg_repetition = eArgRepeatStar;
3654
3655     // There is only one variant this argument could be; put it into the
3656     // argument entry.
3657     arg.push_back(file_arg);
3658
3659     // Push the data for the first argument into the m_arguments vector.
3660     m_arguments.push_back(arg);
3661   }
3662
3663   ~CommandObjectTargetModulesLookup() override = default;
3664
3665   Options *GetOptions() override { return &m_options; }
3666
3667   bool LookupHere(CommandInterpreter &interpreter, CommandReturnObject &result,
3668                   bool &syntax_error) {
3669     switch (m_options.m_type) {
3670     case eLookupTypeAddress:
3671     case eLookupTypeFileLine:
3672     case eLookupTypeFunction:
3673     case eLookupTypeFunctionOrSymbol:
3674     case eLookupTypeSymbol:
3675     default:
3676       return false;
3677     case eLookupTypeType:
3678       break;
3679     }
3680
3681     StackFrameSP frame = m_exe_ctx.GetFrameSP();
3682
3683     if (!frame)
3684       return false;
3685
3686     const SymbolContext &sym_ctx(frame->GetSymbolContext(eSymbolContextModule));
3687
3688     if (!sym_ctx.module_sp)
3689       return false;
3690
3691     switch (m_options.m_type) {
3692     default:
3693       return false;
3694     case eLookupTypeType:
3695       if (!m_options.m_str.empty()) {
3696         if (LookupTypeHere(m_interpreter, result.GetOutputStream(), sym_ctx,
3697                            m_options.m_str.c_str(), m_options.m_use_regex)) {
3698           result.SetStatus(eReturnStatusSuccessFinishResult);
3699           return true;
3700         }
3701       }
3702       break;
3703     }
3704
3705     return true;
3706   }
3707
3708   bool LookupInModule(CommandInterpreter &interpreter, Module *module,
3709                       CommandReturnObject &result, bool &syntax_error) {
3710     switch (m_options.m_type) {
3711     case eLookupTypeAddress:
3712       if (m_options.m_addr != LLDB_INVALID_ADDRESS) {
3713         if (LookupAddressInModule(
3714                 m_interpreter, result.GetOutputStream(), module,
3715                 eSymbolContextEverything |
3716                     (m_options.m_verbose
3717                          ? static_cast<int>(eSymbolContextVariable)
3718                          : 0),
3719                 m_options.m_addr, m_options.m_offset, m_options.m_verbose)) {
3720           result.SetStatus(eReturnStatusSuccessFinishResult);
3721           return true;
3722         }
3723       }
3724       break;
3725
3726     case eLookupTypeSymbol:
3727       if (!m_options.m_str.empty()) {
3728         if (LookupSymbolInModule(m_interpreter, result.GetOutputStream(),
3729                                  module, m_options.m_str.c_str(),
3730                                  m_options.m_use_regex, m_options.m_verbose)) {
3731           result.SetStatus(eReturnStatusSuccessFinishResult);
3732           return true;
3733         }
3734       }
3735       break;
3736
3737     case eLookupTypeFileLine:
3738       if (m_options.m_file) {
3739         if (LookupFileAndLineInModule(
3740                 m_interpreter, result.GetOutputStream(), module,
3741                 m_options.m_file, m_options.m_line_number,
3742                 m_options.m_include_inlines, m_options.m_verbose)) {
3743           result.SetStatus(eReturnStatusSuccessFinishResult);
3744           return true;
3745         }
3746       }
3747       break;
3748
3749     case eLookupTypeFunctionOrSymbol:
3750     case eLookupTypeFunction:
3751       if (!m_options.m_str.empty()) {
3752         if (LookupFunctionInModule(
3753                 m_interpreter, result.GetOutputStream(), module,
3754                 m_options.m_str.c_str(), m_options.m_use_regex,
3755                 m_options.m_include_inlines,
3756                 m_options.m_type ==
3757                     eLookupTypeFunctionOrSymbol, // include symbols
3758                 m_options.m_verbose)) {
3759           result.SetStatus(eReturnStatusSuccessFinishResult);
3760           return true;
3761         }
3762       }
3763       break;
3764
3765     case eLookupTypeType:
3766       if (!m_options.m_str.empty()) {
3767         if (LookupTypeInModule(m_interpreter, result.GetOutputStream(), module,
3768                                m_options.m_str.c_str(),
3769                                m_options.m_use_regex)) {
3770           result.SetStatus(eReturnStatusSuccessFinishResult);
3771           return true;
3772         }
3773       }
3774       break;
3775
3776     default:
3777       m_options.GenerateOptionUsage(
3778           result.GetErrorStream(), this,
3779           GetCommandInterpreter().GetDebugger().GetTerminalWidth());
3780       syntax_error = true;
3781       break;
3782     }
3783
3784     result.SetStatus(eReturnStatusFailed);
3785     return false;
3786   }
3787
3788 protected:
3789   bool DoExecute(Args &command, CommandReturnObject &result) override {
3790     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
3791     if (target == nullptr) {
3792       result.AppendError("invalid target, create a debug target using the "
3793                          "'target create' command");
3794       result.SetStatus(eReturnStatusFailed);
3795       return false;
3796     } else {
3797       bool syntax_error = false;
3798       uint32_t i;
3799       uint32_t num_successful_lookups = 0;
3800       uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
3801       result.GetOutputStream().SetAddressByteSize(addr_byte_size);
3802       result.GetErrorStream().SetAddressByteSize(addr_byte_size);
3803       // Dump all sections for all modules images
3804
3805       if (command.GetArgumentCount() == 0) {
3806         ModuleSP current_module;
3807
3808         // Where it is possible to look in the current symbol context
3809         // first, try that.  If this search was successful and --all
3810         // was not passed, don't print anything else.
3811         if (LookupHere(m_interpreter, result, syntax_error)) {
3812           result.GetOutputStream().EOL();
3813           num_successful_lookups++;
3814           if (!m_options.m_print_all) {
3815             result.SetStatus(eReturnStatusSuccessFinishResult);
3816             return result.Succeeded();
3817           }
3818         }
3819
3820         // Dump all sections for all other modules
3821
3822         const ModuleList &target_modules = target->GetImages();
3823         std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
3824         const size_t num_modules = target_modules.GetSize();
3825         if (num_modules > 0) {
3826           for (i = 0; i < num_modules && !syntax_error; ++i) {
3827             Module *module_pointer =
3828                 target_modules.GetModulePointerAtIndexUnlocked(i);
3829
3830             if (module_pointer != current_module.get() &&
3831                 LookupInModule(
3832                     m_interpreter,
3833                     target_modules.GetModulePointerAtIndexUnlocked(i), result,
3834                     syntax_error)) {
3835               result.GetOutputStream().EOL();
3836               num_successful_lookups++;
3837             }
3838           }
3839         } else {
3840           result.AppendError("the target has no associated executable images");
3841           result.SetStatus(eReturnStatusFailed);
3842           return false;
3843         }
3844       } else {
3845         // Dump specified images (by basename or fullpath)
3846         const char *arg_cstr;
3847         for (i = 0; (arg_cstr = command.GetArgumentAtIndex(i)) != nullptr &&
3848                     !syntax_error;
3849              ++i) {
3850           ModuleList module_list;
3851           const size_t num_matches =
3852               FindModulesByName(target, arg_cstr, module_list, false);
3853           if (num_matches > 0) {
3854             for (size_t j = 0; j < num_matches; ++j) {
3855               Module *module = module_list.GetModulePointerAtIndex(j);
3856               if (module) {
3857                 if (LookupInModule(m_interpreter, module, result,
3858                                    syntax_error)) {
3859                   result.GetOutputStream().EOL();
3860                   num_successful_lookups++;
3861                 }
3862               }
3863             }
3864           } else
3865             result.AppendWarningWithFormat(
3866                 "Unable to find an image that matches '%s'.\n", arg_cstr);
3867         }
3868       }
3869
3870       if (num_successful_lookups > 0)
3871         result.SetStatus(eReturnStatusSuccessFinishResult);
3872       else
3873         result.SetStatus(eReturnStatusFailed);
3874     }
3875     return result.Succeeded();
3876   }
3877
3878   CommandOptions m_options;
3879 };
3880
3881 #pragma mark CommandObjectMultiwordImageSearchPaths
3882
3883 //-------------------------------------------------------------------------
3884 // CommandObjectMultiwordImageSearchPaths
3885 //-------------------------------------------------------------------------
3886
3887 class CommandObjectTargetModulesImageSearchPaths
3888     : public CommandObjectMultiword {
3889 public:
3890   CommandObjectTargetModulesImageSearchPaths(CommandInterpreter &interpreter)
3891       : CommandObjectMultiword(
3892             interpreter, "target modules search-paths",
3893             "Commands for managing module search paths for a target.",
3894             "target modules search-paths <subcommand> [<subcommand-options>]") {
3895     LoadSubCommand(
3896         "add", CommandObjectSP(
3897                    new CommandObjectTargetModulesSearchPathsAdd(interpreter)));
3898     LoadSubCommand(
3899         "clear", CommandObjectSP(new CommandObjectTargetModulesSearchPathsClear(
3900                      interpreter)));
3901     LoadSubCommand(
3902         "insert",
3903         CommandObjectSP(
3904             new CommandObjectTargetModulesSearchPathsInsert(interpreter)));
3905     LoadSubCommand(
3906         "list", CommandObjectSP(new CommandObjectTargetModulesSearchPathsList(
3907                     interpreter)));
3908     LoadSubCommand(
3909         "query", CommandObjectSP(new CommandObjectTargetModulesSearchPathsQuery(
3910                      interpreter)));
3911   }
3912
3913   ~CommandObjectTargetModulesImageSearchPaths() override = default;
3914 };
3915
3916 #pragma mark CommandObjectTargetModules
3917
3918 //-------------------------------------------------------------------------
3919 // CommandObjectTargetModules
3920 //-------------------------------------------------------------------------
3921
3922 class CommandObjectTargetModules : public CommandObjectMultiword {
3923 public:
3924   //------------------------------------------------------------------
3925   // Constructors and Destructors
3926   //------------------------------------------------------------------
3927   CommandObjectTargetModules(CommandInterpreter &interpreter)
3928       : CommandObjectMultiword(interpreter, "target modules",
3929                                "Commands for accessing information for one or "
3930                                "more target modules.",
3931                                "target modules <sub-command> ...") {
3932     LoadSubCommand(
3933         "add", CommandObjectSP(new CommandObjectTargetModulesAdd(interpreter)));
3934     LoadSubCommand("load", CommandObjectSP(new CommandObjectTargetModulesLoad(
3935                                interpreter)));
3936     LoadSubCommand("dump", CommandObjectSP(new CommandObjectTargetModulesDump(
3937                                interpreter)));
3938     LoadSubCommand("list", CommandObjectSP(new CommandObjectTargetModulesList(
3939                                interpreter)));
3940     LoadSubCommand(
3941         "lookup",
3942         CommandObjectSP(new CommandObjectTargetModulesLookup(interpreter)));
3943     LoadSubCommand(
3944         "search-paths",
3945         CommandObjectSP(
3946             new CommandObjectTargetModulesImageSearchPaths(interpreter)));
3947     LoadSubCommand(
3948         "show-unwind",
3949         CommandObjectSP(new CommandObjectTargetModulesShowUnwind(interpreter)));
3950   }
3951
3952   ~CommandObjectTargetModules() override = default;
3953
3954 private:
3955   //------------------------------------------------------------------
3956   // For CommandObjectTargetModules only
3957   //------------------------------------------------------------------
3958   DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetModules);
3959 };
3960
3961 class CommandObjectTargetSymbolsAdd : public CommandObjectParsed {
3962 public:
3963   CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
3964       : CommandObjectParsed(
3965             interpreter, "target symbols add",
3966             "Add a debug symbol file to one of the target's current modules by "
3967             "specifying a path to a debug symbols file, or using the options "
3968             "to specify a module to download symbols for.",
3969             "target symbols add <cmd-options> [<symfile>]",
3970             eCommandRequiresTarget),
3971         m_option_group(),
3972         m_file_option(
3973             LLDB_OPT_SET_1, false, "shlib", 's',
3974             CommandCompletions::eModuleCompletion, eArgTypeShlibName,
3975             "Fullpath or basename for module to find debug symbols for."),
3976         m_current_frame_option(
3977             LLDB_OPT_SET_2, false, "frame", 'F',
3978             "Locate the debug symbols the currently selected frame.", false,
3979             true)
3980
3981   {
3982     m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL,
3983                           LLDB_OPT_SET_1);
3984     m_option_group.Append(&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
3985     m_option_group.Append(&m_current_frame_option, LLDB_OPT_SET_2,
3986                           LLDB_OPT_SET_2);
3987     m_option_group.Finalize();
3988   }
3989
3990   ~CommandObjectTargetSymbolsAdd() override = default;
3991
3992   int HandleArgumentCompletion(Args &input, int &cursor_index,
3993                                int &cursor_char_position,
3994                                OptionElementVector &opt_element_vector,
3995                                int match_start_point, int max_return_elements,
3996                                bool &word_complete,
3997                                StringList &matches) override {
3998     std::string completion_str(input.GetArgumentAtIndex(cursor_index));
3999     completion_str.erase(cursor_char_position);
4000
4001     CommandCompletions::InvokeCommonCompletionCallbacks(
4002         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
4003         completion_str.c_str(), match_start_point, max_return_elements, nullptr,
4004         word_complete, matches);
4005     return matches.GetSize();
4006   }
4007
4008   Options *GetOptions() override { return &m_option_group; }
4009
4010 protected:
4011   bool AddModuleSymbols(Target *target, ModuleSpec &module_spec, bool &flush,
4012                         CommandReturnObject &result) {
4013     const FileSpec &symbol_fspec = module_spec.GetSymbolFileSpec();
4014     if (symbol_fspec) {
4015       char symfile_path[PATH_MAX];
4016       symbol_fspec.GetPath(symfile_path, sizeof(symfile_path));
4017
4018       if (!module_spec.GetUUID().IsValid()) {
4019         if (!module_spec.GetFileSpec() && !module_spec.GetPlatformFileSpec())
4020           module_spec.GetFileSpec().GetFilename() = symbol_fspec.GetFilename();
4021       }
4022       // We now have a module that represents a symbol file
4023       // that can be used for a module that might exist in the
4024       // current target, so we need to find that module in the
4025       // target
4026       ModuleList matching_module_list;
4027
4028       size_t num_matches = 0;
4029       // First extract all module specs from the symbol file
4030       lldb_private::ModuleSpecList symfile_module_specs;
4031       if (ObjectFile::GetModuleSpecifications(module_spec.GetSymbolFileSpec(),
4032                                               0, 0, symfile_module_specs)) {
4033         // Now extract the module spec that matches the target architecture
4034         ModuleSpec target_arch_module_spec;
4035         ModuleSpec symfile_module_spec;
4036         target_arch_module_spec.GetArchitecture() = target->GetArchitecture();
4037         if (symfile_module_specs.FindMatchingModuleSpec(target_arch_module_spec,
4038                                                         symfile_module_spec)) {
4039           // See if it has a UUID?
4040           if (symfile_module_spec.GetUUID().IsValid()) {
4041             // It has a UUID, look for this UUID in the target modules
4042             ModuleSpec symfile_uuid_module_spec;
4043             symfile_uuid_module_spec.GetUUID() = symfile_module_spec.GetUUID();
4044             num_matches = target->GetImages().FindModules(
4045                 symfile_uuid_module_spec, matching_module_list);
4046           }
4047         }
4048
4049         if (num_matches == 0) {
4050           // No matches yet, iterate through the module specs to find a UUID
4051           // value that
4052           // we can match up to an image in our target
4053           const size_t num_symfile_module_specs =
4054               symfile_module_specs.GetSize();
4055           for (size_t i = 0; i < num_symfile_module_specs && num_matches == 0;
4056                ++i) {
4057             if (symfile_module_specs.GetModuleSpecAtIndex(
4058                     i, symfile_module_spec)) {
4059               if (symfile_module_spec.GetUUID().IsValid()) {
4060                 // It has a UUID, look for this UUID in the target modules
4061                 ModuleSpec symfile_uuid_module_spec;
4062                 symfile_uuid_module_spec.GetUUID() =
4063                     symfile_module_spec.GetUUID();
4064                 num_matches = target->GetImages().FindModules(
4065                     symfile_uuid_module_spec, matching_module_list);
4066               }
4067             }
4068           }
4069         }
4070       }
4071
4072       // Just try to match up the file by basename if we have no matches at this
4073       // point
4074       if (num_matches == 0)
4075         num_matches =
4076             target->GetImages().FindModules(module_spec, matching_module_list);
4077
4078       while (num_matches == 0) {
4079         ConstString filename_no_extension(
4080             module_spec.GetFileSpec().GetFileNameStrippingExtension());
4081         // Empty string returned, lets bail
4082         if (!filename_no_extension)
4083           break;
4084
4085         // Check if there was no extension to strip and the basename is the same
4086         if (filename_no_extension == module_spec.GetFileSpec().GetFilename())
4087           break;
4088
4089         // Replace basename with one less extension
4090         module_spec.GetFileSpec().GetFilename() = filename_no_extension;
4091
4092         num_matches =
4093             target->GetImages().FindModules(module_spec, matching_module_list);
4094       }
4095
4096       if (num_matches > 1) {
4097         result.AppendErrorWithFormat("multiple modules match symbol file '%s', "
4098                                      "use the --uuid option to resolve the "
4099                                      "ambiguity.\n",
4100                                      symfile_path);
4101       } else if (num_matches == 1) {
4102         ModuleSP module_sp(matching_module_list.GetModuleAtIndex(0));
4103
4104         // The module has not yet created its symbol vendor, we can just
4105         // give the existing target module the symfile path to use for
4106         // when it decides to create it!
4107         module_sp->SetSymbolFileFileSpec(symbol_fspec);
4108
4109         SymbolVendor *symbol_vendor =
4110             module_sp->GetSymbolVendor(true, &result.GetErrorStream());
4111         if (symbol_vendor) {
4112           SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
4113
4114           if (symbol_file) {
4115             ObjectFile *object_file = symbol_file->GetObjectFile();
4116
4117             if (object_file && object_file->GetFileSpec() == symbol_fspec) {
4118               // Provide feedback that the symfile has been successfully added.
4119               const FileSpec &module_fs = module_sp->GetFileSpec();
4120               result.AppendMessageWithFormat(
4121                   "symbol file '%s' has been added to '%s'\n", symfile_path,
4122                   module_fs.GetPath().c_str());
4123
4124               // Let clients know something changed in the module
4125               // if it is currently loaded
4126               ModuleList module_list;
4127               module_list.Append(module_sp);
4128               target->SymbolsDidLoad(module_list);
4129
4130               // Make sure we load any scripting resources that may be embedded
4131               // in the debug info files in case the platform supports that.
4132               Status error;
4133               StreamString feedback_stream;
4134               module_sp->LoadScriptingResourceInTarget(target, error,
4135                                                        &feedback_stream);
4136               if (error.Fail() && error.AsCString())
4137                 result.AppendWarningWithFormat(
4138                     "unable to load scripting data for module %s - error "
4139                     "reported was %s",
4140                     module_sp->GetFileSpec()
4141                         .GetFileNameStrippingExtension()
4142                         .GetCString(),
4143                     error.AsCString());
4144               else if (feedback_stream.GetSize())
4145                 result.AppendWarningWithFormat("%s", feedback_stream.GetData());
4146
4147               flush = true;
4148               result.SetStatus(eReturnStatusSuccessFinishResult);
4149               return true;
4150             }
4151           }
4152         }
4153         // Clear the symbol file spec if anything went wrong
4154         module_sp->SetSymbolFileFileSpec(FileSpec());
4155       }
4156
4157       namespace fs = llvm::sys::fs;
4158       if (module_spec.GetUUID().IsValid()) {
4159         StreamString ss_symfile_uuid;
4160         module_spec.GetUUID().Dump(&ss_symfile_uuid);
4161         result.AppendErrorWithFormat(
4162             "symbol file '%s' (%s) does not match any existing module%s\n",
4163             symfile_path, ss_symfile_uuid.GetData(),
4164             !fs::is_regular_file(symbol_fspec.GetPath())
4165                 ? "\n       please specify the full path to the symbol file"
4166                 : "");
4167       } else {
4168         result.AppendErrorWithFormat(
4169             "symbol file '%s' does not match any existing module%s\n",
4170             symfile_path,
4171             !fs::is_regular_file(symbol_fspec.GetPath())
4172                 ? "\n       please specify the full path to the symbol file"
4173                 : "");
4174       }
4175     } else {
4176       result.AppendError(
4177           "one or more executable image paths must be specified");
4178     }
4179     result.SetStatus(eReturnStatusFailed);
4180     return false;
4181   }
4182
4183   bool DoExecute(Args &args, CommandReturnObject &result) override {
4184     Target *target = m_exe_ctx.GetTargetPtr();
4185     result.SetStatus(eReturnStatusFailed);
4186     bool flush = false;
4187     ModuleSpec module_spec;
4188     const bool uuid_option_set =
4189         m_uuid_option_group.GetOptionValue().OptionWasSet();
4190     const bool file_option_set = m_file_option.GetOptionValue().OptionWasSet();
4191     const bool frame_option_set =
4192         m_current_frame_option.GetOptionValue().OptionWasSet();
4193     const size_t argc = args.GetArgumentCount();
4194
4195     if (argc == 0) {
4196       if (uuid_option_set || file_option_set || frame_option_set) {
4197         bool success = false;
4198         bool error_set = false;
4199         if (frame_option_set) {
4200           Process *process = m_exe_ctx.GetProcessPtr();
4201           if (process) {
4202             const StateType process_state = process->GetState();
4203             if (StateIsStoppedState(process_state, true)) {
4204               StackFrame *frame = m_exe_ctx.GetFramePtr();
4205               if (frame) {
4206                 ModuleSP frame_module_sp(
4207                     frame->GetSymbolContext(eSymbolContextModule).module_sp);
4208                 if (frame_module_sp) {
4209                   if (frame_module_sp->GetPlatformFileSpec().Exists()) {
4210                     module_spec.GetArchitecture() =
4211                         frame_module_sp->GetArchitecture();
4212                     module_spec.GetFileSpec() =
4213                         frame_module_sp->GetPlatformFileSpec();
4214                   }
4215                   module_spec.GetUUID() = frame_module_sp->GetUUID();
4216                   success = module_spec.GetUUID().IsValid() ||
4217                             module_spec.GetFileSpec();
4218                 } else {
4219                   result.AppendError("frame has no module");
4220                   error_set = true;
4221                 }
4222               } else {
4223                 result.AppendError("invalid current frame");
4224                 error_set = true;
4225               }
4226             } else {
4227               result.AppendErrorWithFormat("process is not stopped: %s",
4228                                            StateAsCString(process_state));
4229               error_set = true;
4230             }
4231           } else {
4232             result.AppendError(
4233                 "a process must exist in order to use the --frame option");
4234             error_set = true;
4235           }
4236         } else {
4237           if (uuid_option_set) {
4238             module_spec.GetUUID() =
4239                 m_uuid_option_group.GetOptionValue().GetCurrentValue();
4240             success |= module_spec.GetUUID().IsValid();
4241           } else if (file_option_set) {
4242             module_spec.GetFileSpec() =
4243                 m_file_option.GetOptionValue().GetCurrentValue();
4244             ModuleSP module_sp(
4245                 target->GetImages().FindFirstModule(module_spec));
4246             if (module_sp) {
4247               module_spec.GetFileSpec() = module_sp->GetFileSpec();
4248               module_spec.GetPlatformFileSpec() =
4249                   module_sp->GetPlatformFileSpec();
4250               module_spec.GetUUID() = module_sp->GetUUID();
4251               module_spec.GetArchitecture() = module_sp->GetArchitecture();
4252             } else {
4253               module_spec.GetArchitecture() = target->GetArchitecture();
4254             }
4255             success |= module_spec.GetUUID().IsValid() ||
4256                        module_spec.GetFileSpec().Exists();
4257           }
4258         }
4259
4260         if (success) {
4261           if (Symbols::DownloadObjectAndSymbolFile(module_spec)) {
4262             if (module_spec.GetSymbolFileSpec())
4263               success = AddModuleSymbols(target, module_spec, flush, result);
4264           }
4265         }
4266
4267         if (!success && !error_set) {
4268           StreamString error_strm;
4269           if (uuid_option_set) {
4270             error_strm.PutCString("unable to find debug symbols for UUID ");
4271             module_spec.GetUUID().Dump(&error_strm);
4272           } else if (file_option_set) {
4273             error_strm.PutCString(
4274                 "unable to find debug symbols for the executable file ");
4275             error_strm << module_spec.GetFileSpec();
4276           } else if (frame_option_set) {
4277             error_strm.PutCString(
4278                 "unable to find debug symbols for the current frame");
4279           }
4280           result.AppendError(error_strm.GetString());
4281         }
4282       } else {
4283         result.AppendError("one or more symbol file paths must be specified, "
4284                            "or options must be specified");
4285       }
4286     } else {
4287       if (uuid_option_set) {
4288         result.AppendError("specify either one or more paths to symbol files "
4289                            "or use the --uuid option without arguments");
4290       } else if (frame_option_set) {
4291         result.AppendError("specify either one or more paths to symbol files "
4292                            "or use the --frame option without arguments");
4293       } else if (file_option_set && argc > 1) {
4294         result.AppendError("specify at most one symbol file path when "
4295                            "--shlib option is set");
4296       } else {
4297         PlatformSP platform_sp(target->GetPlatform());
4298
4299         for (auto &entry : args.entries()) {
4300           if (!entry.ref.empty()) {
4301             module_spec.GetSymbolFileSpec().SetFile(entry.ref, true);
4302             if (file_option_set) {
4303               module_spec.GetFileSpec() =
4304                   m_file_option.GetOptionValue().GetCurrentValue();
4305             }
4306             if (platform_sp) {
4307               FileSpec symfile_spec;
4308               if (platform_sp
4309                       ->ResolveSymbolFile(*target, module_spec, symfile_spec)
4310                       .Success())
4311                 module_spec.GetSymbolFileSpec() = symfile_spec;
4312             }
4313
4314             ArchSpec arch;
4315             bool symfile_exists = module_spec.GetSymbolFileSpec().Exists();
4316
4317             if (symfile_exists) {
4318               if (!AddModuleSymbols(target, module_spec, flush, result))
4319                 break;
4320             } else {
4321               std::string resolved_symfile_path =
4322                   module_spec.GetSymbolFileSpec().GetPath();
4323               if (resolved_symfile_path != entry.ref) {
4324                 result.AppendErrorWithFormat(
4325                     "invalid module path '%s' with resolved path '%s'\n",
4326                     entry.c_str(), resolved_symfile_path.c_str());
4327                 break;
4328               }
4329               result.AppendErrorWithFormat("invalid module path '%s'\n",
4330                                            entry.c_str());
4331               break;
4332             }
4333           }
4334         }
4335       }
4336     }
4337
4338     if (flush) {
4339       Process *process = m_exe_ctx.GetProcessPtr();
4340       if (process)
4341         process->Flush();
4342     }
4343     return result.Succeeded();
4344   }
4345
4346   OptionGroupOptions m_option_group;
4347   OptionGroupUUID m_uuid_option_group;
4348   OptionGroupFile m_file_option;
4349   OptionGroupBoolean m_current_frame_option;
4350 };
4351
4352 #pragma mark CommandObjectTargetSymbols
4353
4354 //-------------------------------------------------------------------------
4355 // CommandObjectTargetSymbols
4356 //-------------------------------------------------------------------------
4357
4358 class CommandObjectTargetSymbols : public CommandObjectMultiword {
4359 public:
4360   //------------------------------------------------------------------
4361   // Constructors and Destructors
4362   //------------------------------------------------------------------
4363   CommandObjectTargetSymbols(CommandInterpreter &interpreter)
4364       : CommandObjectMultiword(
4365             interpreter, "target symbols",
4366             "Commands for adding and managing debug symbol files.",
4367             "target symbols <sub-command> ...") {
4368     LoadSubCommand(
4369         "add", CommandObjectSP(new CommandObjectTargetSymbolsAdd(interpreter)));
4370   }
4371
4372   ~CommandObjectTargetSymbols() override = default;
4373
4374 private:
4375   //------------------------------------------------------------------
4376   // For CommandObjectTargetModules only
4377   //------------------------------------------------------------------
4378   DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetSymbols);
4379 };
4380
4381 #pragma mark CommandObjectTargetStopHookAdd
4382
4383 //-------------------------------------------------------------------------
4384 // CommandObjectTargetStopHookAdd
4385 //-------------------------------------------------------------------------
4386
4387 static OptionDefinition g_target_stop_hook_add_options[] = {
4388     // clang-format off
4389   { LLDB_OPT_SET_ALL, false, "one-liner",    'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOneLiner,                                         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
4390   { LLDB_OPT_SET_ALL, false, "shlib",        's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion, eArgTypeShlibName,    "Set the module within which the stop-hook is to be run." },
4391   { LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadIndex,                                      "The stop hook is run only for the thread whose index matches this argument." },
4392   { LLDB_OPT_SET_ALL, false, "thread-id",    't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadID,                                         "The stop hook is run only for the thread whose TID matches this argument." },
4393   { LLDB_OPT_SET_ALL, false, "thread-name",  'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadName,                                       "The stop hook is run only for the thread whose thread name matches this argument." },
4394   { LLDB_OPT_SET_ALL, false, "queue-name",   'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeQueueName,                                        "The stop hook is run only for threads in the queue whose name is given by this argument." },
4395   { LLDB_OPT_SET_1,   false, "file",         'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the source file within which the stop-hook is to be run." },
4396   { LLDB_OPT_SET_1,   false, "start-line",   'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,                                          "Set the start of the line range for which the stop-hook is to be run." },
4397   { LLDB_OPT_SET_1,   false, "end-line",     'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,                                          "Set the end of the line range for which the stop-hook is to be run." },
4398   { LLDB_OPT_SET_2,   false, "classname",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeClassName,                                        "Specify the class within which the stop-hook is to be run." },
4399   { LLDB_OPT_SET_3,   false, "name",         'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the function name within which the stop hook will be run." },
4400     // clang-format on
4401 };
4402
4403 class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
4404                                        public IOHandlerDelegateMultiline {
4405 public:
4406   class CommandOptions : public Options {
4407   public:
4408     CommandOptions()
4409         : Options(), m_line_start(0), m_line_end(UINT_MAX),
4410           m_func_name_type_mask(eFunctionNameTypeAuto),
4411           m_sym_ctx_specified(false), m_thread_specified(false),
4412           m_use_one_liner(false), m_one_liner() {}
4413
4414     ~CommandOptions() override = default;
4415
4416     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
4417       return llvm::makeArrayRef(g_target_stop_hook_add_options);
4418     }
4419
4420     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
4421                           ExecutionContext *execution_context) override {
4422       Status error;
4423       const int short_option = m_getopt_table[option_idx].val;
4424
4425       switch (short_option) {
4426       case 'c':
4427         m_class_name = option_arg;
4428         m_sym_ctx_specified = true;
4429         break;
4430
4431       case 'e':
4432         if (option_arg.getAsInteger(0, m_line_end)) {
4433           error.SetErrorStringWithFormat("invalid end line number: \"%s\"",
4434                                          option_arg.str().c_str());
4435           break;
4436         }
4437         m_sym_ctx_specified = true;
4438         break;
4439
4440       case 'l':
4441         if (option_arg.getAsInteger(0, m_line_start)) {
4442           error.SetErrorStringWithFormat("invalid start line number: \"%s\"",
4443                                          option_arg.str().c_str());
4444           break;
4445         }
4446         m_sym_ctx_specified = true;
4447         break;
4448
4449       case 'i':
4450         m_no_inlines = true;
4451         break;
4452
4453       case 'n':
4454         m_function_name = option_arg;
4455         m_func_name_type_mask |= eFunctionNameTypeAuto;
4456         m_sym_ctx_specified = true;
4457         break;
4458
4459       case 'f':
4460         m_file_name = option_arg;
4461         m_sym_ctx_specified = true;
4462         break;
4463
4464       case 's':
4465         m_module_name = option_arg;
4466         m_sym_ctx_specified = true;
4467         break;
4468
4469       case 't':
4470         if (option_arg.getAsInteger(0, m_thread_id))
4471           error.SetErrorStringWithFormat("invalid thread id string '%s'",
4472                                          option_arg.str().c_str());
4473         m_thread_specified = true;
4474         break;
4475
4476       case 'T':
4477         m_thread_name = option_arg;
4478         m_thread_specified = true;
4479         break;
4480
4481       case 'q':
4482         m_queue_name = option_arg;
4483         m_thread_specified = true;
4484         break;
4485
4486       case 'x':
4487         if (option_arg.getAsInteger(0, m_thread_index))
4488           error.SetErrorStringWithFormat("invalid thread index string '%s'",
4489                                          option_arg.str().c_str());
4490         m_thread_specified = true;
4491         break;
4492
4493       case 'o':
4494         m_use_one_liner = true;
4495         m_one_liner = option_arg;
4496         break;
4497
4498       default:
4499         error.SetErrorStringWithFormat("unrecognized option %c.", short_option);
4500         break;
4501       }
4502       return error;
4503     }
4504
4505     void OptionParsingStarting(ExecutionContext *execution_context) override {
4506       m_class_name.clear();
4507       m_function_name.clear();
4508       m_line_start = 0;
4509       m_line_end = UINT_MAX;
4510       m_file_name.clear();
4511       m_module_name.clear();
4512       m_func_name_type_mask = eFunctionNameTypeAuto;
4513       m_thread_id = LLDB_INVALID_THREAD_ID;
4514       m_thread_index = UINT32_MAX;
4515       m_thread_name.clear();
4516       m_queue_name.clear();
4517
4518       m_no_inlines = false;
4519       m_sym_ctx_specified = false;
4520       m_thread_specified = false;
4521
4522       m_use_one_liner = false;
4523       m_one_liner.clear();
4524     }
4525
4526     std::string m_class_name;
4527     std::string m_function_name;
4528     uint32_t m_line_start;
4529     uint32_t m_line_end;
4530     std::string m_file_name;
4531     std::string m_module_name;
4532     uint32_t m_func_name_type_mask; // A pick from lldb::FunctionNameType.
4533     lldb::tid_t m_thread_id;
4534     uint32_t m_thread_index;
4535     std::string m_thread_name;
4536     std::string m_queue_name;
4537     bool m_sym_ctx_specified;
4538     bool m_no_inlines;
4539     bool m_thread_specified;
4540     // Instance variables to hold the values for one_liner options.
4541     bool m_use_one_liner;
4542     std::string m_one_liner;
4543   };
4544
4545   CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
4546       : CommandObjectParsed(interpreter, "target stop-hook add",
4547                             "Add a hook to be executed when the target stops.",
4548                             "target stop-hook add"),
4549         IOHandlerDelegateMultiline("DONE",
4550                                    IOHandlerDelegate::Completion::LLDBCommand),
4551         m_options() {}
4552
4553   ~CommandObjectTargetStopHookAdd() override = default;
4554
4555   Options *GetOptions() override { return &m_options; }
4556
4557 protected:
4558   void IOHandlerActivated(IOHandler &io_handler) override {
4559     StreamFileSP output_sp(io_handler.GetOutputStreamFile());
4560     if (output_sp) {
4561       output_sp->PutCString(
4562           "Enter your stop hook command(s).  Type 'DONE' to end.\n");
4563       output_sp->Flush();
4564     }
4565   }
4566
4567   void IOHandlerInputComplete(IOHandler &io_handler,
4568                               std::string &line) override {
4569     if (m_stop_hook_sp) {
4570       if (line.empty()) {
4571         StreamFileSP error_sp(io_handler.GetErrorStreamFile());
4572         if (error_sp) {
4573           error_sp->Printf("error: stop hook #%" PRIu64
4574                            " aborted, no commands.\n",
4575                            m_stop_hook_sp->GetID());
4576           error_sp->Flush();
4577         }
4578         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
4579         if (target)
4580           target->RemoveStopHookByID(m_stop_hook_sp->GetID());
4581       } else {
4582         m_stop_hook_sp->GetCommandPointer()->SplitIntoLines(line);
4583         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
4584         if (output_sp) {
4585           output_sp->Printf("Stop hook #%" PRIu64 " added.\n",
4586                             m_stop_hook_sp->GetID());
4587           output_sp->Flush();
4588         }
4589       }
4590       m_stop_hook_sp.reset();
4591     }
4592     io_handler.SetIsDone(true);
4593   }
4594
4595   bool DoExecute(Args &command, CommandReturnObject &result) override {
4596     m_stop_hook_sp.reset();
4597
4598     Target *target = GetSelectedOrDummyTarget();
4599     if (target) {
4600       Target::StopHookSP new_hook_sp = target->CreateStopHook();
4601
4602       //  First step, make the specifier.
4603       std::unique_ptr<SymbolContextSpecifier> specifier_ap;
4604       if (m_options.m_sym_ctx_specified) {
4605         specifier_ap.reset(new SymbolContextSpecifier(
4606             m_interpreter.GetDebugger().GetSelectedTarget()));
4607
4608         if (!m_options.m_module_name.empty()) {
4609           specifier_ap->AddSpecification(
4610               m_options.m_module_name.c_str(),
4611               SymbolContextSpecifier::eModuleSpecified);
4612         }
4613
4614         if (!m_options.m_class_name.empty()) {
4615           specifier_ap->AddSpecification(
4616               m_options.m_class_name.c_str(),
4617               SymbolContextSpecifier::eClassOrNamespaceSpecified);
4618         }
4619
4620         if (!m_options.m_file_name.empty()) {
4621           specifier_ap->AddSpecification(
4622               m_options.m_file_name.c_str(),
4623               SymbolContextSpecifier::eFileSpecified);
4624         }
4625
4626         if (m_options.m_line_start != 0) {
4627           specifier_ap->AddLineSpecification(
4628               m_options.m_line_start,
4629               SymbolContextSpecifier::eLineStartSpecified);
4630         }
4631
4632         if (m_options.m_line_end != UINT_MAX) {
4633           specifier_ap->AddLineSpecification(
4634               m_options.m_line_end, SymbolContextSpecifier::eLineEndSpecified);
4635         }
4636
4637         if (!m_options.m_function_name.empty()) {
4638           specifier_ap->AddSpecification(
4639               m_options.m_function_name.c_str(),
4640               SymbolContextSpecifier::eFunctionSpecified);
4641         }
4642       }
4643
4644       if (specifier_ap)
4645         new_hook_sp->SetSpecifier(specifier_ap.release());
4646
4647       // Next see if any of the thread options have been entered:
4648
4649       if (m_options.m_thread_specified) {
4650         ThreadSpec *thread_spec = new ThreadSpec();
4651
4652         if (m_options.m_thread_id != LLDB_INVALID_THREAD_ID) {
4653           thread_spec->SetTID(m_options.m_thread_id);
4654         }
4655
4656         if (m_options.m_thread_index != UINT32_MAX)
4657           thread_spec->SetIndex(m_options.m_thread_index);
4658
4659         if (!m_options.m_thread_name.empty())
4660           thread_spec->SetName(m_options.m_thread_name.c_str());
4661
4662         if (!m_options.m_queue_name.empty())
4663           thread_spec->SetQueueName(m_options.m_queue_name.c_str());
4664
4665         new_hook_sp->SetThreadSpecifier(thread_spec);
4666       }
4667       if (m_options.m_use_one_liner) {
4668         // Use one-liner.
4669         new_hook_sp->GetCommandPointer()->AppendString(
4670             m_options.m_one_liner.c_str());
4671         result.AppendMessageWithFormat("Stop hook #%" PRIu64 " added.\n",
4672                                        new_hook_sp->GetID());
4673       } else {
4674         m_stop_hook_sp = new_hook_sp;
4675         m_interpreter.GetLLDBCommandsFromIOHandler(
4676             "> ",     // Prompt
4677             *this,    // IOHandlerDelegate
4678             true,     // Run IOHandler in async mode
4679             nullptr); // Baton for the "io_handler" that will be passed back
4680                       // into our IOHandlerDelegate functions
4681       }
4682       result.SetStatus(eReturnStatusSuccessFinishNoResult);
4683     } else {
4684       result.AppendError("invalid target\n");
4685       result.SetStatus(eReturnStatusFailed);
4686     }
4687
4688     return result.Succeeded();
4689   }
4690
4691 private:
4692   CommandOptions m_options;
4693   Target::StopHookSP m_stop_hook_sp;
4694 };
4695
4696 #pragma mark CommandObjectTargetStopHookDelete
4697
4698 //-------------------------------------------------------------------------
4699 // CommandObjectTargetStopHookDelete
4700 //-------------------------------------------------------------------------
4701
4702 class CommandObjectTargetStopHookDelete : public CommandObjectParsed {
4703 public:
4704   CommandObjectTargetStopHookDelete(CommandInterpreter &interpreter)
4705       : CommandObjectParsed(interpreter, "target stop-hook delete",
4706                             "Delete a stop-hook.",
4707                             "target stop-hook delete [<idx>]") {}
4708
4709   ~CommandObjectTargetStopHookDelete() override = default;
4710
4711 protected:
4712   bool DoExecute(Args &command, CommandReturnObject &result) override {
4713     Target *target = GetSelectedOrDummyTarget();
4714     if (target) {
4715       // FIXME: see if we can use the breakpoint id style parser?
4716       size_t num_args = command.GetArgumentCount();
4717       if (num_args == 0) {
4718         if (!m_interpreter.Confirm("Delete all stop hooks?", true)) {
4719           result.SetStatus(eReturnStatusFailed);
4720           return false;
4721         } else {
4722           target->RemoveAllStopHooks();
4723         }
4724       } else {
4725         bool success;
4726         for (size_t i = 0; i < num_args; i++) {
4727           lldb::user_id_t user_id = StringConvert::ToUInt32(
4728               command.GetArgumentAtIndex(i), 0, 0, &success);
4729           if (!success) {
4730             result.AppendErrorWithFormat("invalid stop hook id: \"%s\".\n",
4731                                          command.GetArgumentAtIndex(i));
4732             result.SetStatus(eReturnStatusFailed);
4733             return false;
4734           }
4735           success = target->RemoveStopHookByID(user_id);
4736           if (!success) {
4737             result.AppendErrorWithFormat("unknown stop hook id: \"%s\".\n",
4738                                          command.GetArgumentAtIndex(i));
4739             result.SetStatus(eReturnStatusFailed);
4740             return false;
4741           }
4742         }
4743       }
4744       result.SetStatus(eReturnStatusSuccessFinishNoResult);
4745     } else {
4746       result.AppendError("invalid target\n");
4747       result.SetStatus(eReturnStatusFailed);
4748     }
4749
4750     return result.Succeeded();
4751   }
4752 };
4753
4754 #pragma mark CommandObjectTargetStopHookEnableDisable
4755
4756 //-------------------------------------------------------------------------
4757 // CommandObjectTargetStopHookEnableDisable
4758 //-------------------------------------------------------------------------
4759
4760 class CommandObjectTargetStopHookEnableDisable : public CommandObjectParsed {
4761 public:
4762   CommandObjectTargetStopHookEnableDisable(CommandInterpreter &interpreter,
4763                                            bool enable, const char *name,
4764                                            const char *help, const char *syntax)
4765       : CommandObjectParsed(interpreter, name, help, syntax), m_enable(enable) {
4766   }
4767
4768   ~CommandObjectTargetStopHookEnableDisable() override = default;
4769
4770 protected:
4771   bool DoExecute(Args &command, CommandReturnObject &result) override {
4772     Target *target = GetSelectedOrDummyTarget();
4773     if (target) {
4774       // FIXME: see if we can use the breakpoint id style parser?
4775       size_t num_args = command.GetArgumentCount();
4776       bool success;
4777
4778       if (num_args == 0) {
4779         target->SetAllStopHooksActiveState(m_enable);
4780       } else {
4781         for (size_t i = 0; i < num_args; i++) {
4782           lldb::user_id_t user_id = StringConvert::ToUInt32(
4783               command.GetArgumentAtIndex(i), 0, 0, &success);
4784           if (!success) {
4785             result.AppendErrorWithFormat("invalid stop hook id: \"%s\".\n",
4786                                          command.GetArgumentAtIndex(i));
4787             result.SetStatus(eReturnStatusFailed);
4788             return false;
4789           }
4790           success = target->SetStopHookActiveStateByID(user_id, m_enable);
4791           if (!success) {
4792             result.AppendErrorWithFormat("unknown stop hook id: \"%s\".\n",
4793                                          command.GetArgumentAtIndex(i));
4794             result.SetStatus(eReturnStatusFailed);
4795             return false;
4796           }
4797         }
4798       }
4799       result.SetStatus(eReturnStatusSuccessFinishNoResult);
4800     } else {
4801       result.AppendError("invalid target\n");
4802       result.SetStatus(eReturnStatusFailed);
4803     }
4804     return result.Succeeded();
4805   }
4806
4807 private:
4808   bool m_enable;
4809 };
4810
4811 #pragma mark CommandObjectTargetStopHookList
4812
4813 //-------------------------------------------------------------------------
4814 // CommandObjectTargetStopHookList
4815 //-------------------------------------------------------------------------
4816
4817 class CommandObjectTargetStopHookList : public CommandObjectParsed {
4818 public:
4819   CommandObjectTargetStopHookList(CommandInterpreter &interpreter)
4820       : CommandObjectParsed(interpreter, "target stop-hook list",
4821                             "List all stop-hooks.",
4822                             "target stop-hook list [<type>]") {}
4823
4824   ~CommandObjectTargetStopHookList() override = default;
4825
4826 protected:
4827   bool DoExecute(Args &command, CommandReturnObject &result) override {
4828     Target *target = GetSelectedOrDummyTarget();
4829     if (!target) {
4830       result.AppendError("invalid target\n");
4831       result.SetStatus(eReturnStatusFailed);
4832       return result.Succeeded();
4833     }
4834
4835     size_t num_hooks = target->GetNumStopHooks();
4836     if (num_hooks == 0) {
4837       result.GetOutputStream().PutCString("No stop hooks.\n");
4838     } else {
4839       for (size_t i = 0; i < num_hooks; i++) {
4840         Target::StopHookSP this_hook = target->GetStopHookAtIndex(i);
4841         if (i > 0)
4842           result.GetOutputStream().PutCString("\n");
4843         this_hook->GetDescription(&(result.GetOutputStream()),
4844                                   eDescriptionLevelFull);
4845       }
4846     }
4847     result.SetStatus(eReturnStatusSuccessFinishResult);
4848     return result.Succeeded();
4849   }
4850 };
4851
4852 #pragma mark CommandObjectMultiwordTargetStopHooks
4853
4854 //-------------------------------------------------------------------------
4855 // CommandObjectMultiwordTargetStopHooks
4856 //-------------------------------------------------------------------------
4857
4858 class CommandObjectMultiwordTargetStopHooks : public CommandObjectMultiword {
4859 public:
4860   CommandObjectMultiwordTargetStopHooks(CommandInterpreter &interpreter)
4861       : CommandObjectMultiword(
4862             interpreter, "target stop-hook",
4863             "Commands for operating on debugger target stop-hooks.",
4864             "target stop-hook <subcommand> [<subcommand-options>]") {
4865     LoadSubCommand("add", CommandObjectSP(
4866                               new CommandObjectTargetStopHookAdd(interpreter)));
4867     LoadSubCommand(
4868         "delete",
4869         CommandObjectSP(new CommandObjectTargetStopHookDelete(interpreter)));
4870     LoadSubCommand("disable",
4871                    CommandObjectSP(new CommandObjectTargetStopHookEnableDisable(
4872                        interpreter, false, "target stop-hook disable [<id>]",
4873                        "Disable a stop-hook.", "target stop-hook disable")));
4874     LoadSubCommand("enable",
4875                    CommandObjectSP(new CommandObjectTargetStopHookEnableDisable(
4876                        interpreter, true, "target stop-hook enable [<id>]",
4877                        "Enable a stop-hook.", "target stop-hook enable")));
4878     LoadSubCommand("list", CommandObjectSP(new CommandObjectTargetStopHookList(
4879                                interpreter)));
4880   }
4881
4882   ~CommandObjectMultiwordTargetStopHooks() override = default;
4883 };
4884
4885 #pragma mark CommandObjectMultiwordTarget
4886
4887 //-------------------------------------------------------------------------
4888 // CommandObjectMultiwordTarget
4889 //-------------------------------------------------------------------------
4890
4891 CommandObjectMultiwordTarget::CommandObjectMultiwordTarget(
4892     CommandInterpreter &interpreter)
4893     : CommandObjectMultiword(interpreter, "target",
4894                              "Commands for operating on debugger targets.",
4895                              "target <subcommand> [<subcommand-options>]") {
4896   LoadSubCommand("create",
4897                  CommandObjectSP(new CommandObjectTargetCreate(interpreter)));
4898   LoadSubCommand("delete",
4899                  CommandObjectSP(new CommandObjectTargetDelete(interpreter)));
4900   LoadSubCommand("list",
4901                  CommandObjectSP(new CommandObjectTargetList(interpreter)));
4902   LoadSubCommand("select",
4903                  CommandObjectSP(new CommandObjectTargetSelect(interpreter)));
4904   LoadSubCommand(
4905       "stop-hook",
4906       CommandObjectSP(new CommandObjectMultiwordTargetStopHooks(interpreter)));
4907   LoadSubCommand("modules",
4908                  CommandObjectSP(new CommandObjectTargetModules(interpreter)));
4909   LoadSubCommand("symbols",
4910                  CommandObjectSP(new CommandObjectTargetSymbols(interpreter)));
4911   LoadSubCommand("variable",
4912                  CommandObjectSP(new CommandObjectTargetVariable(interpreter)));
4913 }
4914
4915 CommandObjectMultiwordTarget::~CommandObjectMultiwordTarget() = default;