lldb/source/Commands/CommandObjectPlatform.cpp

   1 //===-- CommandObjectPlatform.cpp -------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "CommandObjectPlatform.h"
  10 #include "lldb/Core/Debugger.h"
  11 #include "lldb/Core/Module.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Host/OptionParser.h"
  14 #include "lldb/Host/StringConvert.h"
  15 #include "lldb/Interpreter/CommandInterpreter.h"
  16 #include "lldb/Interpreter/CommandOptionValidators.h"
  17 #include "lldb/Interpreter/CommandReturnObject.h"
  18 #include "lldb/Interpreter/OptionGroupFile.h"
  19 #include "lldb/Interpreter/OptionGroupPlatform.h"
  20 #include "lldb/Target/ExecutionContext.h"
  21 #include "lldb/Target/Platform.h"
  22 #include "lldb/Target/Process.h"
  23 #include "lldb/Utility/Args.h"
  24
  25 #include "llvm/ADT/SmallString.h"
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 static mode_t ParsePermissionString(const char *) = delete;
  31
  32 static mode_t ParsePermissionString(llvm::StringRef permissions) {
  33   if (permissions.size() != 9)
  34     return (mode_t)(-1);
  35   bool user_r, user_w, user_x, group_r, group_w, group_x, world_r, world_w,
  36       world_x;
  37
  38   user_r = (permissions[0] == 'r');
  39   user_w = (permissions[1] == 'w');
  40   user_x = (permissions[2] == 'x');
  41
  42   group_r = (permissions[3] == 'r');
  43   group_w = (permissions[4] == 'w');
  44   group_x = (permissions[5] == 'x');
  45
  46   world_r = (permissions[6] == 'r');
  47   world_w = (permissions[7] == 'w');
  48   world_x = (permissions[8] == 'x');
  49
  50   mode_t user, group, world;
  51   user = (user_r ? 4 : 0) | (user_w ? 2 : 0) | (user_x ? 1 : 0);
  52   group = (group_r ? 4 : 0) | (group_w ? 2 : 0) | (group_x ? 1 : 0);
  53   world = (world_r ? 4 : 0) | (world_w ? 2 : 0) | (world_x ? 1 : 0);
  54
  55   return user | group | world;
  56 }
  57
  58 #define LLDB_OPTIONS_permissions
  59 #include "CommandOptions.inc"
  60
  61 class OptionPermissions : public OptionGroup {
  62 public:
  63   OptionPermissions() {}
  64
  65   ~OptionPermissions() override = default;
  66
  67   lldb_private::Status
  68   SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  69                  ExecutionContext *execution_context) override {
  70     Status error;
  71     char short_option = (char)GetDefinitions()[option_idx].short_option;
  72     switch (short_option) {
  73     case 'v': {
  74       if (option_arg.getAsInteger(8, m_permissions)) {
  75         m_permissions = 0777;
  76         error.SetErrorStringWithFormat("invalid value for permissions: %s",
  77                                        option_arg.str().c_str());
  78       }
  79
  80     } break;
  81     case 's': {
  82       mode_t perms = ParsePermissionString(option_arg);
  83       if (perms == (mode_t)-1)
  84         error.SetErrorStringWithFormat("invalid value for permissions: %s",
  85                                        option_arg.str().c_str());
  86       else
  87         m_permissions = perms;
  88     } break;
  89     case 'r':
  90       m_permissions |= lldb::eFilePermissionsUserRead;
  91       break;
  92     case 'w':
  93       m_permissions |= lldb::eFilePermissionsUserWrite;
  94       break;
  95     case 'x':
  96       m_permissions |= lldb::eFilePermissionsUserExecute;
  97       break;
  98     case 'R':
  99       m_permissions |= lldb::eFilePermissionsGroupRead;
 100       break;
 101     case 'W':
 102       m_permissions |= lldb::eFilePermissionsGroupWrite;
 103       break;
 104     case 'X':
 105       m_permissions |= lldb::eFilePermissionsGroupExecute;
 106       break;
 107     case 'd':
 108       m_permissions |= lldb::eFilePermissionsWorldRead;
 109       break;
 110     case 't':
 111       m_permissions |= lldb::eFilePermissionsWorldWrite;
 112       break;
 113     case 'e':
 114       m_permissions |= lldb::eFilePermissionsWorldExecute;
 115       break;
 116     default:
 117       llvm_unreachable("Unimplemented option");
 118     }
 119
 120     return error;
 121   }
 122
 123   void OptionParsingStarting(ExecutionContext *execution_context) override {
 124     m_permissions = 0;
 125   }
 126
 127   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 128     return llvm::makeArrayRef(g_permissions_options);
 129   }
 130
 131   // Instance variables to hold the values for command options.
 132
 133   uint32_t m_permissions;
 134
 135 private:
 136   DISALLOW_COPY_AND_ASSIGN(OptionPermissions);
 137 };
 138
 139 // "platform select <platform-name>"
 140 class CommandObjectPlatformSelect : public CommandObjectParsed {
 141 public:
 142   CommandObjectPlatformSelect(CommandInterpreter &interpreter)
 143       : CommandObjectParsed(interpreter, "platform select",
 144                             "Create a platform if needed and select it as the "
 145                             "current platform.",
 146                             "platform select <platform-name>", 0),
 147         m_option_group(),
 148         m_platform_options(
 149             false) // Don't include the "--platform" option by passing false
 150   {
 151     m_option_group.Append(&m_platform_options, LLDB_OPT_SET_ALL, 1);
 152     m_option_group.Finalize();
 153   }
 154
 155   ~CommandObjectPlatformSelect() override = default;
 156
 157   void HandleCompletion(CompletionRequest &request) override {
 158     CommandCompletions::PlatformPluginNames(GetCommandInterpreter(), request,
 159                                             nullptr);
 160   }
 161
 162   Options *GetOptions() override { return &m_option_group; }
 163
 164 protected:
 165   bool DoExecute(Args &args, CommandReturnObject &result) override {
 166     if (args.GetArgumentCount() == 1) {
 167       const char *platform_name = args.GetArgumentAtIndex(0);
 168       if (platform_name && platform_name[0]) {
 169         const bool select = true;
 170         m_platform_options.SetPlatformName(platform_name);
 171         Status error;
 172         ArchSpec platform_arch;
 173         PlatformSP platform_sp(m_platform_options.CreatePlatformWithOptions(
 174             m_interpreter, ArchSpec(), select, error, platform_arch));
 175         if (platform_sp) {
 176           GetDebugger().GetPlatformList().SetSelectedPlatform(platform_sp);
 177
 178           platform_sp->GetStatus(result.GetOutputStream());
 179           result.SetStatus(eReturnStatusSuccessFinishResult);
 180         } else {
 181           result.AppendError(error.AsCString());
 182           result.SetStatus(eReturnStatusFailed);
 183         }
 184       } else {
 185         result.AppendError("invalid platform name");
 186         result.SetStatus(eReturnStatusFailed);
 187       }
 188     } else {
 189       result.AppendError(
 190           "platform create takes a platform name as an argument\n");
 191       result.SetStatus(eReturnStatusFailed);
 192     }
 193     return result.Succeeded();
 194   }
 195
 196   OptionGroupOptions m_option_group;
 197   OptionGroupPlatform m_platform_options;
 198 };
 199
 200 // "platform list"
 201 class CommandObjectPlatformList : public CommandObjectParsed {
 202 public:
 203   CommandObjectPlatformList(CommandInterpreter &interpreter)
 204       : CommandObjectParsed(interpreter, "platform list",
 205                             "List all platforms that are available.", nullptr,
 206                             0) {}
 207
 208   ~CommandObjectPlatformList() override = default;
 209
 210 protected:
 211   bool DoExecute(Args &args, CommandReturnObject &result) override {
 212     Stream &ostrm = result.GetOutputStream();
 213     ostrm.Printf("Available platforms:\n");
 214
 215     PlatformSP host_platform_sp(Platform::GetHostPlatform());
 216     ostrm.Printf("%s: %s\n", host_platform_sp->GetPluginName().GetCString(),
 217                  host_platform_sp->GetDescription());
 218
 219     uint32_t idx;
 220     for (idx = 0; true; ++idx) {
 221       const char *plugin_name =
 222           PluginManager::GetPlatformPluginNameAtIndex(idx);
 223       if (plugin_name == nullptr)
 224         break;
 225       const char *plugin_desc =
 226           PluginManager::GetPlatformPluginDescriptionAtIndex(idx);
 227       if (plugin_desc == nullptr)
 228         break;
 229       ostrm.Printf("%s: %s\n", plugin_name, plugin_desc);
 230     }
 231
 232     if (idx == 0) {
 233       result.AppendError("no platforms are available\n");
 234       result.SetStatus(eReturnStatusFailed);
 235     } else
 236       result.SetStatus(eReturnStatusSuccessFinishResult);
 237     return result.Succeeded();
 238   }
 239 };
 240
 241 // "platform status"
 242 class CommandObjectPlatformStatus : public CommandObjectParsed {
 243 public:
 244   CommandObjectPlatformStatus(CommandInterpreter &interpreter)
 245       : CommandObjectParsed(interpreter, "platform status",
 246                             "Display status for the current platform.", nullptr,
 247                             0) {}
 248
 249   ~CommandObjectPlatformStatus() override = default;
 250
 251 protected:
 252   bool DoExecute(Args &args, CommandReturnObject &result) override {
 253     Stream &ostrm = result.GetOutputStream();
 254
 255     Target *target = GetDebugger().GetSelectedTarget().get();
 256     PlatformSP platform_sp;
 257     if (target) {
 258       platform_sp = target->GetPlatform();
 259     }
 260     if (!platform_sp) {
 261       platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform();
 262     }
 263     if (platform_sp) {
 264       platform_sp->GetStatus(ostrm);
 265       result.SetStatus(eReturnStatusSuccessFinishResult);
 266     } else {
 267       result.AppendError("no platform is currently selected\n");
 268       result.SetStatus(eReturnStatusFailed);
 269     }
 270     return result.Succeeded();
 271   }
 272 };
 273
 274 // "platform connect <connect-url>"
 275 class CommandObjectPlatformConnect : public CommandObjectParsed {
 276 public:
 277   CommandObjectPlatformConnect(CommandInterpreter &interpreter)
 278       : CommandObjectParsed(
 279             interpreter, "platform connect",
 280             "Select the current platform by providing a connection URL.",
 281             "platform connect <connect-url>", 0) {}
 282
 283   ~CommandObjectPlatformConnect() override = default;
 284
 285 protected:
 286   bool DoExecute(Args &args, CommandReturnObject &result) override {
 287     Stream &ostrm = result.GetOutputStream();
 288
 289     PlatformSP platform_sp(
 290         GetDebugger().GetPlatformList().GetSelectedPlatform());
 291     if (platform_sp) {
 292       Status error(platform_sp->ConnectRemote(args));
 293       if (error.Success()) {
 294         platform_sp->GetStatus(ostrm);
 295         result.SetStatus(eReturnStatusSuccessFinishResult);
 296
 297         platform_sp->ConnectToWaitingProcesses(GetDebugger(), error);
 298         if (error.Fail()) {
 299           result.AppendError(error.AsCString());
 300           result.SetStatus(eReturnStatusFailed);
 301         }
 302       } else {
 303         result.AppendErrorWithFormat("%s\n", error.AsCString());
 304         result.SetStatus(eReturnStatusFailed);
 305       }
 306     } else {
 307       result.AppendError("no platform is currently selected\n");
 308       result.SetStatus(eReturnStatusFailed);
 309     }
 310     return result.Succeeded();
 311   }
 312
 313   Options *GetOptions() override {
 314     PlatformSP platform_sp(
 315         GetDebugger().GetPlatformList().GetSelectedPlatform());
 316     OptionGroupOptions *m_platform_options = nullptr;
 317     if (platform_sp) {
 318       m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
 319       if (m_platform_options != nullptr && !m_platform_options->m_did_finalize)
 320         m_platform_options->Finalize();
 321     }
 322     return m_platform_options;
 323   }
 324 };
 325
 326 // "platform disconnect"
 327 class CommandObjectPlatformDisconnect : public CommandObjectParsed {
 328 public:
 329   CommandObjectPlatformDisconnect(CommandInterpreter &interpreter)
 330       : CommandObjectParsed(interpreter, "platform disconnect",
 331                             "Disconnect from the current platform.",
 332                             "platform disconnect", 0) {}
 333
 334   ~CommandObjectPlatformDisconnect() override = default;
 335
 336 protected:
 337   bool DoExecute(Args &args, CommandReturnObject &result) override {
 338     PlatformSP platform_sp(
 339         GetDebugger().GetPlatformList().GetSelectedPlatform());
 340     if (platform_sp) {
 341       if (args.GetArgumentCount() == 0) {
 342         Status error;
 343
 344         if (platform_sp->IsConnected()) {
 345           // Cache the instance name if there is one since we are about to
 346           // disconnect and the name might go with it.
 347           const char *hostname_cstr = platform_sp->GetHostname();
 348           std::string hostname;
 349           if (hostname_cstr)
 350             hostname.assign(hostname_cstr);
 351
 352           error = platform_sp->DisconnectRemote();
 353           if (error.Success()) {
 354             Stream &ostrm = result.GetOutputStream();
 355             if (hostname.empty())
 356               ostrm.Printf("Disconnected from \"%s\"\n",
 357                            platform_sp->GetPluginName().GetCString());
 358             else
 359               ostrm.Printf("Disconnected from \"%s\"\n", hostname.c_str());
 360             result.SetStatus(eReturnStatusSuccessFinishResult);
 361           } else {
 362             result.AppendErrorWithFormat("%s", error.AsCString());
 363             result.SetStatus(eReturnStatusFailed);
 364           }
 365         } else {
 366           // Not connected...
 367           result.AppendErrorWithFormat(
 368               "not connected to '%s'",
 369               platform_sp->GetPluginName().GetCString());
 370           result.SetStatus(eReturnStatusFailed);
 371         }
 372       } else {
 373         // Bad args
 374         result.AppendError(
 375             "\"platform disconnect\" doesn't take any arguments");
 376         result.SetStatus(eReturnStatusFailed);
 377       }
 378     } else {
 379       result.AppendError("no platform is currently selected");
 380       result.SetStatus(eReturnStatusFailed);
 381     }
 382     return result.Succeeded();
 383   }
 384 };
 385
 386 // "platform settings"
 387 class CommandObjectPlatformSettings : public CommandObjectParsed {
 388 public:
 389   CommandObjectPlatformSettings(CommandInterpreter &interpreter)
 390       : CommandObjectParsed(interpreter, "platform settings",
 391                             "Set settings for the current target's platform, "
 392                             "or for a platform by name.",
 393                             "platform settings", 0),
 394         m_options(),
 395         m_option_working_dir(LLDB_OPT_SET_1, false, "working-dir", 'w', 0,
 396                              eArgTypePath,
 397                              "The working directory for the platform.") {
 398     m_options.Append(&m_option_working_dir, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
 399   }
 400
 401   ~CommandObjectPlatformSettings() override = default;
 402
 403 protected:
 404   bool DoExecute(Args &args, CommandReturnObject &result) override {
 405     PlatformSP platform_sp(
 406         GetDebugger().GetPlatformList().GetSelectedPlatform());
 407     if (platform_sp) {
 408       if (m_option_working_dir.GetOptionValue().OptionWasSet())
 409         platform_sp->SetWorkingDirectory(
 410             m_option_working_dir.GetOptionValue().GetCurrentValue());
 411     } else {
 412       result.AppendError("no platform is currently selected");
 413       result.SetStatus(eReturnStatusFailed);
 414     }
 415     return result.Succeeded();
 416   }
 417
 418   Options *GetOptions() override {
 419     if (!m_options.DidFinalize())
 420       m_options.Finalize();
 421     return &m_options;
 422   }
 423
 424 protected:
 425   OptionGroupOptions m_options;
 426   OptionGroupFile m_option_working_dir;
 427 };
 428
 429 // "platform mkdir"
 430 class CommandObjectPlatformMkDir : public CommandObjectParsed {
 431 public:
 432   CommandObjectPlatformMkDir(CommandInterpreter &interpreter)
 433       : CommandObjectParsed(interpreter, "platform mkdir",
 434                             "Make a new directory on the remote end.", nullptr,
 435                             0),
 436         m_options() {}
 437
 438   ~CommandObjectPlatformMkDir() override = default;
 439
 440   bool DoExecute(Args &args, CommandReturnObject &result) override {
 441     PlatformSP platform_sp(
 442         GetDebugger().GetPlatformList().GetSelectedPlatform());
 443     if (platform_sp) {
 444       std::string cmd_line;
 445       args.GetCommandString(cmd_line);
 446       uint32_t mode;
 447       const OptionPermissions *options_permissions =
 448           (const OptionPermissions *)m_options.GetGroupWithOption('r');
 449       if (options_permissions)
 450         mode = options_permissions->m_permissions;
 451       else
 452         mode = lldb::eFilePermissionsUserRWX | lldb::eFilePermissionsGroupRWX |
 453                lldb::eFilePermissionsWorldRX;
 454       Status error = platform_sp->MakeDirectory(FileSpec(cmd_line), mode);
 455       if (error.Success()) {
 456         result.SetStatus(eReturnStatusSuccessFinishResult);
 457       } else {
 458         result.AppendError(error.AsCString());
 459         result.SetStatus(eReturnStatusFailed);
 460       }
 461     } else {
 462       result.AppendError("no platform currently selected\n");
 463       result.SetStatus(eReturnStatusFailed);
 464     }
 465     return result.Succeeded();
 466   }
 467
 468   Options *GetOptions() override {
 469     if (!m_options.DidFinalize()) {
 470       m_options.Append(new OptionPermissions());
 471       m_options.Finalize();
 472     }
 473     return &m_options;
 474   }
 475
 476   OptionGroupOptions m_options;
 477 };
 478
 479 // "platform fopen"
 480 class CommandObjectPlatformFOpen : public CommandObjectParsed {
 481 public:
 482   CommandObjectPlatformFOpen(CommandInterpreter &interpreter)
 483       : CommandObjectParsed(interpreter, "platform file open",
 484                             "Open a file on the remote end.", nullptr, 0),
 485         m_options() {}
 486
 487   ~CommandObjectPlatformFOpen() override = default;
 488
 489   bool DoExecute(Args &args, CommandReturnObject &result) override {
 490     PlatformSP platform_sp(
 491         GetDebugger().GetPlatformList().GetSelectedPlatform());
 492     if (platform_sp) {
 493       Status error;
 494       std::string cmd_line;
 495       args.GetCommandString(cmd_line);
 496       mode_t perms;
 497       const OptionPermissions *options_permissions =
 498           (const OptionPermissions *)m_options.GetGroupWithOption('r');
 499       if (options_permissions)
 500         perms = options_permissions->m_permissions;
 501       else
 502         perms = lldb::eFilePermissionsUserRW | lldb::eFilePermissionsGroupRW |
 503                 lldb::eFilePermissionsWorldRead;
 504       lldb::user_id_t fd = platform_sp->OpenFile(
 505           FileSpec(cmd_line),
 506           File::eOpenOptionRead | File::eOpenOptionWrite |
 507               File::eOpenOptionAppend | File::eOpenOptionCanCreate,
 508           perms, error);
 509       if (error.Success()) {
 510         result.AppendMessageWithFormat("File Descriptor = %" PRIu64 "\n", fd);
 511         result.SetStatus(eReturnStatusSuccessFinishResult);
 512       } else {
 513         result.AppendError(error.AsCString());
 514         result.SetStatus(eReturnStatusFailed);
 515       }
 516     } else {
 517       result.AppendError("no platform currently selected\n");
 518       result.SetStatus(eReturnStatusFailed);
 519     }
 520     return result.Succeeded();
 521   }
 522
 523   Options *GetOptions() override {
 524     if (!m_options.DidFinalize()) {
 525       m_options.Append(new OptionPermissions());
 526       m_options.Finalize();
 527     }
 528     return &m_options;
 529   }
 530
 531   OptionGroupOptions m_options;
 532 };
 533
 534 // "platform fclose"
 535 class CommandObjectPlatformFClose : public CommandObjectParsed {
 536 public:
 537   CommandObjectPlatformFClose(CommandInterpreter &interpreter)
 538       : CommandObjectParsed(interpreter, "platform file close",
 539                             "Close a file on the remote end.", nullptr, 0) {}
 540
 541   ~CommandObjectPlatformFClose() override = default;
 542
 543   bool DoExecute(Args &args, CommandReturnObject &result) override {
 544     PlatformSP platform_sp(
 545         GetDebugger().GetPlatformList().GetSelectedPlatform());
 546     if (platform_sp) {
 547       std::string cmd_line;
 548       args.GetCommandString(cmd_line);
 549       const lldb::user_id_t fd =
 550           StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
 551       Status error;
 552       bool success = platform_sp->CloseFile(fd, error);
 553       if (success) {
 554         result.AppendMessageWithFormat("file %" PRIu64 " closed.\n", fd);
 555         result.SetStatus(eReturnStatusSuccessFinishResult);
 556       } else {
 557         result.AppendError(error.AsCString());
 558         result.SetStatus(eReturnStatusFailed);
 559       }
 560     } else {
 561       result.AppendError("no platform currently selected\n");
 562       result.SetStatus(eReturnStatusFailed);
 563     }
 564     return result.Succeeded();
 565   }
 566 };
 567
 568 // "platform fread"
 569
 570 #define LLDB_OPTIONS_platform_fread
 571 #include "CommandOptions.inc"
 572
 573 class CommandObjectPlatformFRead : public CommandObjectParsed {
 574 public:
 575   CommandObjectPlatformFRead(CommandInterpreter &interpreter)
 576       : CommandObjectParsed(interpreter, "platform file read",
 577                             "Read data from a file on the remote end.", nullptr,
 578                             0),
 579         m_options() {}
 580
 581   ~CommandObjectPlatformFRead() override = default;
 582
 583   bool DoExecute(Args &args, CommandReturnObject &result) override {
 584     PlatformSP platform_sp(
 585         GetDebugger().GetPlatformList().GetSelectedPlatform());
 586     if (platform_sp) {
 587       std::string cmd_line;
 588       args.GetCommandString(cmd_line);
 589       const lldb::user_id_t fd =
 590           StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
 591       std::string buffer(m_options.m_count, 0);
 592       Status error;
 593       uint32_t retcode = platform_sp->ReadFile(
 594           fd, m_options.m_offset, &buffer[0], m_options.m_count, error);
 595       result.AppendMessageWithFormat("Return = %d\n", retcode);
 596       result.AppendMessageWithFormat("Data = \"%s\"\n", buffer.c_str());
 597       result.SetStatus(eReturnStatusSuccessFinishResult);
 598     } else {
 599       result.AppendError("no platform currently selected\n");
 600       result.SetStatus(eReturnStatusFailed);
 601     }
 602     return result.Succeeded();
 603   }
 604
 605   Options *GetOptions() override { return &m_options; }
 606
 607 protected:
 608   class CommandOptions : public Options {
 609   public:
 610     CommandOptions() : Options() {}
 611
 612     ~CommandOptions() override = default;
 613
 614     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 615                           ExecutionContext *execution_context) override {
 616       Status error;
 617       char short_option = (char)m_getopt_table[option_idx].val;
 618
 619       switch (short_option) {
 620       case 'o':
 621         if (option_arg.getAsInteger(0, m_offset))
 622           error.SetErrorStringWithFormat("invalid offset: '%s'",
 623                                          option_arg.str().c_str());
 624         break;
 625       case 'c':
 626         if (option_arg.getAsInteger(0, m_count))
 627           error.SetErrorStringWithFormat("invalid offset: '%s'",
 628                                          option_arg.str().c_str());
 629         break;
 630       default:
 631         llvm_unreachable("Unimplemented option");
 632       }
 633
 634       return error;
 635     }
 636
 637     void OptionParsingStarting(ExecutionContext *execution_context) override {
 638       m_offset = 0;
 639       m_count = 1;
 640     }
 641
 642     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 643       return llvm::makeArrayRef(g_platform_fread_options);
 644     }
 645
 646     // Instance variables to hold the values for command options.
 647
 648     uint32_t m_offset;
 649     uint32_t m_count;
 650   };
 651
 652   CommandOptions m_options;
 653 };
 654
 655 // "platform fwrite"
 656
 657 #define LLDB_OPTIONS_platform_fwrite
 658 #include "CommandOptions.inc"
 659
 660 class CommandObjectPlatformFWrite : public CommandObjectParsed {
 661 public:
 662   CommandObjectPlatformFWrite(CommandInterpreter &interpreter)
 663       : CommandObjectParsed(interpreter, "platform file write",
 664                             "Write data to a file on the remote end.", nullptr,
 665                             0),
 666         m_options() {}
 667
 668   ~CommandObjectPlatformFWrite() override = default;
 669
 670   bool DoExecute(Args &args, CommandReturnObject &result) override {
 671     PlatformSP platform_sp(
 672         GetDebugger().GetPlatformList().GetSelectedPlatform());
 673     if (platform_sp) {
 674       std::string cmd_line;
 675       args.GetCommandString(cmd_line);
 676       Status error;
 677       const lldb::user_id_t fd =
 678           StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
 679       uint32_t retcode =
 680           platform_sp->WriteFile(fd, m_options.m_offset, &m_options.m_data[0],
 681                                  m_options.m_data.size(), error);
 682       result.AppendMessageWithFormat("Return = %d\n", retcode);
 683       result.SetStatus(eReturnStatusSuccessFinishResult);
 684     } else {
 685       result.AppendError("no platform currently selected\n");
 686       result.SetStatus(eReturnStatusFailed);
 687     }
 688     return result.Succeeded();
 689   }
 690
 691   Options *GetOptions() override { return &m_options; }
 692
 693 protected:
 694   class CommandOptions : public Options {
 695   public:
 696     CommandOptions() : Options() {}
 697
 698     ~CommandOptions() override = default;
 699
 700     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 701                           ExecutionContext *execution_context) override {
 702       Status error;
 703       char short_option = (char)m_getopt_table[option_idx].val;
 704
 705       switch (short_option) {
 706       case 'o':
 707         if (option_arg.getAsInteger(0, m_offset))
 708           error.SetErrorStringWithFormat("invalid offset: '%s'",
 709                                          option_arg.str().c_str());
 710         break;
 711       case 'd':
 712         m_data.assign(option_arg);
 713         break;
 714       default:
 715         llvm_unreachable("Unimplemented option");
 716       }
 717
 718       return error;
 719     }
 720
 721     void OptionParsingStarting(ExecutionContext *execution_context) override {
 722       m_offset = 0;
 723       m_data.clear();
 724     }
 725
 726     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 727       return llvm::makeArrayRef(g_platform_fwrite_options);
 728     }
 729
 730     // Instance variables to hold the values for command options.
 731
 732     uint32_t m_offset;
 733     std::string m_data;
 734   };
 735
 736   CommandOptions m_options;
 737 };
 738
 739 class CommandObjectPlatformFile : public CommandObjectMultiword {
 740 public:
 741   // Constructors and Destructors
 742   CommandObjectPlatformFile(CommandInterpreter &interpreter)
 743       : CommandObjectMultiword(
 744             interpreter, "platform file",
 745             "Commands to access files on the current platform.",
 746             "platform file [open|close|read|write] ...") {
 747     LoadSubCommand(
 748         "open", CommandObjectSP(new CommandObjectPlatformFOpen(interpreter)));
 749     LoadSubCommand(
 750         "close", CommandObjectSP(new CommandObjectPlatformFClose(interpreter)));
 751     LoadSubCommand(
 752         "read", CommandObjectSP(new CommandObjectPlatformFRead(interpreter)));
 753     LoadSubCommand(
 754         "write", CommandObjectSP(new CommandObjectPlatformFWrite(interpreter)));
 755   }
 756
 757   ~CommandObjectPlatformFile() override = default;
 758
 759 private:
 760   // For CommandObjectPlatform only
 761   DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformFile);
 762 };
 763
 764 // "platform get-file remote-file-path host-file-path"
 765 class CommandObjectPlatformGetFile : public CommandObjectParsed {
 766 public:
 767   CommandObjectPlatformGetFile(CommandInterpreter &interpreter)
 768       : CommandObjectParsed(
 769             interpreter, "platform get-file",
 770             "Transfer a file from the remote end to the local host.",
 771             "platform get-file <remote-file-spec> <local-file-spec>", 0) {
 772     SetHelpLong(
 773         R"(Examples:
 774
 775 (lldb) platform get-file /the/remote/file/path /the/local/file/path
 776
 777     Transfer a file from the remote end with file path /the/remote/file/path to the local host.)");
 778
 779     CommandArgumentEntry arg1, arg2;
 780     CommandArgumentData file_arg_remote, file_arg_host;
 781
 782     // Define the first (and only) variant of this arg.
 783     file_arg_remote.arg_type = eArgTypeFilename;
 784     file_arg_remote.arg_repetition = eArgRepeatPlain;
 785     // There is only one variant this argument could be; put it into the
 786     // argument entry.
 787     arg1.push_back(file_arg_remote);
 788
 789     // Define the second (and only) variant of this arg.
 790     file_arg_host.arg_type = eArgTypeFilename;
 791     file_arg_host.arg_repetition = eArgRepeatPlain;
 792     // There is only one variant this argument could be; put it into the
 793     // argument entry.
 794     arg2.push_back(file_arg_host);
 795
 796     // Push the data for the first and the second arguments into the
 797     // m_arguments vector.
 798     m_arguments.push_back(arg1);
 799     m_arguments.push_back(arg2);
 800   }
 801
 802   ~CommandObjectPlatformGetFile() override = default;
 803
 804   bool DoExecute(Args &args, CommandReturnObject &result) override {
 805     // If the number of arguments is incorrect, issue an error message.
 806     if (args.GetArgumentCount() != 2) {
 807       result.GetErrorStream().Printf("error: required arguments missing; "
 808                                      "specify both the source and destination "
 809                                      "file paths\n");
 810       result.SetStatus(eReturnStatusFailed);
 811       return false;
 812     }
 813
 814     PlatformSP platform_sp(
 815         GetDebugger().GetPlatformList().GetSelectedPlatform());
 816     if (platform_sp) {
 817       const char *remote_file_path = args.GetArgumentAtIndex(0);
 818       const char *local_file_path = args.GetArgumentAtIndex(1);
 819       Status error = platform_sp->GetFile(FileSpec(remote_file_path),
 820                                           FileSpec(local_file_path));
 821       if (error.Success()) {
 822         result.AppendMessageWithFormat(
 823             "successfully get-file from %s (remote) to %s (host)\n",
 824             remote_file_path, local_file_path);
 825         result.SetStatus(eReturnStatusSuccessFinishResult);
 826       } else {
 827         result.AppendMessageWithFormat("get-file failed: %s\n",
 828                                        error.AsCString());
 829         result.SetStatus(eReturnStatusFailed);
 830       }
 831     } else {
 832       result.AppendError("no platform currently selected\n");
 833       result.SetStatus(eReturnStatusFailed);
 834     }
 835     return result.Succeeded();
 836   }
 837 };
 838
 839 // "platform get-size remote-file-path"
 840 class CommandObjectPlatformGetSize : public CommandObjectParsed {
 841 public:
 842   CommandObjectPlatformGetSize(CommandInterpreter &interpreter)
 843       : CommandObjectParsed(interpreter, "platform get-size",
 844                             "Get the file size from the remote end.",
 845                             "platform get-size <remote-file-spec>", 0) {
 846     SetHelpLong(
 847         R"(Examples:
 848
 849 (lldb) platform get-size /the/remote/file/path
 850
 851     Get the file size from the remote end with path /the/remote/file/path.)");
 852
 853     CommandArgumentEntry arg1;
 854     CommandArgumentData file_arg_remote;
 855
 856     // Define the first (and only) variant of this arg.
 857     file_arg_remote.arg_type = eArgTypeFilename;
 858     file_arg_remote.arg_repetition = eArgRepeatPlain;
 859     // There is only one variant this argument could be; put it into the
 860     // argument entry.
 861     arg1.push_back(file_arg_remote);
 862
 863     // Push the data for the first argument into the m_arguments vector.
 864     m_arguments.push_back(arg1);
 865   }
 866
 867   ~CommandObjectPlatformGetSize() override = default;
 868
 869   bool DoExecute(Args &args, CommandReturnObject &result) override {
 870     // If the number of arguments is incorrect, issue an error message.
 871     if (args.GetArgumentCount() != 1) {
 872       result.GetErrorStream().Printf("error: required argument missing; "
 873                                      "specify the source file path as the only "
 874                                      "argument\n");
 875       result.SetStatus(eReturnStatusFailed);
 876       return false;
 877     }
 878
 879     PlatformSP platform_sp(
 880         GetDebugger().GetPlatformList().GetSelectedPlatform());
 881     if (platform_sp) {
 882       std::string remote_file_path(args.GetArgumentAtIndex(0));
 883       user_id_t size = platform_sp->GetFileSize(FileSpec(remote_file_path));
 884       if (size != UINT64_MAX) {
 885         result.AppendMessageWithFormat("File size of %s (remote): %" PRIu64
 886                                        "\n",
 887                                        remote_file_path.c_str(), size);
 888         result.SetStatus(eReturnStatusSuccessFinishResult);
 889       } else {
 890         result.AppendMessageWithFormat(
 891             "Error getting file size of %s (remote)\n",
 892             remote_file_path.c_str());
 893         result.SetStatus(eReturnStatusFailed);
 894       }
 895     } else {
 896       result.AppendError("no platform currently selected\n");
 897       result.SetStatus(eReturnStatusFailed);
 898     }
 899     return result.Succeeded();
 900   }
 901 };
 902
 903 // "platform put-file"
 904 class CommandObjectPlatformPutFile : public CommandObjectParsed {
 905 public:
 906   CommandObjectPlatformPutFile(CommandInterpreter &interpreter)
 907       : CommandObjectParsed(
 908             interpreter, "platform put-file",
 909             "Transfer a file from this system to the remote end.", nullptr, 0) {
 910   }
 911
 912   ~CommandObjectPlatformPutFile() override = default;
 913
 914   bool DoExecute(Args &args, CommandReturnObject &result) override {
 915     const char *src = args.GetArgumentAtIndex(0);
 916     const char *dst = args.GetArgumentAtIndex(1);
 917
 918     FileSpec src_fs(src);
 919     FileSystem::Instance().Resolve(src_fs);
 920     FileSpec dst_fs(dst ? dst : src_fs.GetFilename().GetCString());
 921
 922     PlatformSP platform_sp(
 923         GetDebugger().GetPlatformList().GetSelectedPlatform());
 924     if (platform_sp) {
 925       Status error(platform_sp->PutFile(src_fs, dst_fs));
 926       if (error.Success()) {
 927         result.SetStatus(eReturnStatusSuccessFinishNoResult);
 928       } else {
 929         result.AppendError(error.AsCString());
 930         result.SetStatus(eReturnStatusFailed);
 931       }
 932     } else {
 933       result.AppendError("no platform currently selected\n");
 934       result.SetStatus(eReturnStatusFailed);
 935     }
 936     return result.Succeeded();
 937   }
 938 };
 939
 940 // "platform process launch"
 941 class CommandObjectPlatformProcessLaunch : public CommandObjectParsed {
 942 public:
 943   CommandObjectPlatformProcessLaunch(CommandInterpreter &interpreter)
 944       : CommandObjectParsed(interpreter, "platform process launch",
 945                             "Launch a new process on a remote platform.",
 946                             "platform process launch program",
 947                             eCommandRequiresTarget | eCommandTryTargetAPILock),
 948         m_options() {}
 949
 950   ~CommandObjectPlatformProcessLaunch() override = default;
 951
 952   Options *GetOptions() override { return &m_options; }
 953
 954 protected:
 955   bool DoExecute(Args &args, CommandReturnObject &result) override {
 956     Target *target = GetDebugger().GetSelectedTarget().get();
 957     PlatformSP platform_sp;
 958     if (target) {
 959       platform_sp = target->GetPlatform();
 960     }
 961     if (!platform_sp) {
 962       platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform();
 963     }
 964
 965     if (platform_sp) {
 966       Status error;
 967       const size_t argc = args.GetArgumentCount();
 968       Target *target = m_exe_ctx.GetTargetPtr();
 969       Module *exe_module = target->GetExecutableModulePointer();
 970       if (exe_module) {
 971         m_options.launch_info.GetExecutableFile() = exe_module->GetFileSpec();
 972         llvm::SmallString<128> exe_path;
 973         m_options.launch_info.GetExecutableFile().GetPath(exe_path);
 974         if (!exe_path.empty())
 975           m_options.launch_info.GetArguments().AppendArgument(exe_path);
 976         m_options.launch_info.GetArchitecture() = exe_module->GetArchitecture();
 977       }
 978
 979       if (argc > 0) {
 980         if (m_options.launch_info.GetExecutableFile()) {
 981           // We already have an executable file, so we will use this and all
 982           // arguments to this function are extra arguments
 983           m_options.launch_info.GetArguments().AppendArguments(args);
 984         } else {
 985           // We don't have any file yet, so the first argument is our
 986           // executable, and the rest are program arguments
 987           const bool first_arg_is_executable = true;
 988           m_options.launch_info.SetArguments(args, first_arg_is_executable);
 989         }
 990       }
 991
 992       if (m_options.launch_info.GetExecutableFile()) {
 993         Debugger &debugger = GetDebugger();
 994
 995         if (argc == 0)
 996           target->GetRunArguments(m_options.launch_info.GetArguments());
 997
 998         ProcessSP process_sp(platform_sp->DebugProcess(
 999             m_options.launch_info, debugger, target, error));
1000         if (process_sp && process_sp->IsAlive()) {
1001           result.SetStatus(eReturnStatusSuccessFinishNoResult);
1002           return true;
1003         }
1004
1005         if (error.Success())
1006           result.AppendError("process launch failed");
1007         else
1008           result.AppendError(error.AsCString());
1009         result.SetStatus(eReturnStatusFailed);
1010       } else {
1011         result.AppendError("'platform process launch' uses the current target "
1012                            "file and arguments, or the executable and its "
1013                            "arguments can be specified in this command");
1014         result.SetStatus(eReturnStatusFailed);
1015         return false;
1016       }
1017     } else {
1018       result.AppendError("no platform is selected\n");
1019     }
1020     return result.Succeeded();
1021   }
1022
1023 protected:
1024   ProcessLaunchCommandOptions m_options;
1025 };
1026
1027 // "platform process list"
1028
1029 static PosixPlatformCommandOptionValidator posix_validator;
1030 #define LLDB_OPTIONS_platform_process_list
1031 #include "CommandOptions.inc"
1032
1033 class CommandObjectPlatformProcessList : public CommandObjectParsed {
1034 public:
1035   CommandObjectPlatformProcessList(CommandInterpreter &interpreter)
1036       : CommandObjectParsed(interpreter, "platform process list",
1037                             "List processes on a remote platform by name, pid, "
1038                             "or many other matching attributes.",
1039                             "platform process list", 0),
1040         m_options() {}
1041
1042   ~CommandObjectPlatformProcessList() override = default;
1043
1044   Options *GetOptions() override { return &m_options; }
1045
1046 protected:
1047   bool DoExecute(Args &args, CommandReturnObject &result) override {
1048     Target *target = GetDebugger().GetSelectedTarget().get();
1049     PlatformSP platform_sp;
1050     if (target) {
1051       platform_sp = target->GetPlatform();
1052     }
1053     if (!platform_sp) {
1054       platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform();
1055     }
1056
1057     if (platform_sp) {
1058       Status error;
1059       if (args.GetArgumentCount() == 0) {
1060         if (platform_sp) {
1061           Stream &ostrm = result.GetOutputStream();
1062
1063           lldb::pid_t pid =
1064               m_options.match_info.GetProcessInfo().GetProcessID();
1065           if (pid != LLDB_INVALID_PROCESS_ID) {
1066             ProcessInstanceInfo proc_info;
1067             if (platform_sp->GetProcessInfo(pid, proc_info)) {
1068               ProcessInstanceInfo::DumpTableHeader(ostrm, m_options.show_args,
1069                                                    m_options.verbose);
1070               proc_info.DumpAsTableRow(ostrm, platform_sp->GetUserIDResolver(),
1071                                        m_options.show_args, m_options.verbose);
1072               result.SetStatus(eReturnStatusSuccessFinishResult);
1073             } else {
1074               result.AppendErrorWithFormat(
1075                   "no process found with pid = %" PRIu64 "\n", pid);
1076               result.SetStatus(eReturnStatusFailed);
1077             }
1078           } else {
1079             ProcessInstanceInfoList proc_infos;
1080             const uint32_t matches =
1081                 platform_sp->FindProcesses(m_options.match_info, proc_infos);
1082             const char *match_desc = nullptr;
1083             const char *match_name =
1084                 m_options.match_info.GetProcessInfo().GetName();
1085             if (match_name && match_name[0]) {
1086               switch (m_options.match_info.GetNameMatchType()) {
1087               case NameMatch::Ignore:
1088                 break;
1089               case NameMatch::Equals:
1090                 match_desc = "matched";
1091                 break;
1092               case NameMatch::Contains:
1093                 match_desc = "contained";
1094                 break;
1095               case NameMatch::StartsWith:
1096                 match_desc = "started with";
1097                 break;
1098               case NameMatch::EndsWith:
1099                 match_desc = "ended with";
1100                 break;
1101               case NameMatch::RegularExpression:
1102                 match_desc = "matched the regular expression";
1103                 break;
1104               }
1105             }
1106
1107             if (matches == 0) {
1108               if (match_desc)
1109                 result.AppendErrorWithFormat(
1110                     "no processes were found that %s \"%s\" on the \"%s\" "
1111                     "platform\n",
1112                     match_desc, match_name,
1113                     platform_sp->GetPluginName().GetCString());
1114               else
1115                 result.AppendErrorWithFormat(
1116                     "no processes were found on the \"%s\" platform\n",
1117                     platform_sp->GetPluginName().GetCString());
1118               result.SetStatus(eReturnStatusFailed);
1119             } else {
1120               result.AppendMessageWithFormat(
1121                   "%u matching process%s found on \"%s\"", matches,
1122                   matches > 1 ? "es were" : " was",
1123                   platform_sp->GetName().GetCString());
1124               if (match_desc)
1125                 result.AppendMessageWithFormat(" whose name %s \"%s\"",
1126                                                match_desc, match_name);
1127               result.AppendMessageWithFormat("\n");
1128               ProcessInstanceInfo::DumpTableHeader(ostrm, m_options.show_args,
1129                                                    m_options.verbose);
1130               for (uint32_t i = 0; i < matches; ++i) {
1131                 proc_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(
1132                     ostrm, platform_sp->GetUserIDResolver(),
1133                     m_options.show_args, m_options.verbose);
1134               }
1135             }
1136           }
1137         }
1138       } else {
1139         result.AppendError("invalid args: process list takes only options\n");
1140         result.SetStatus(eReturnStatusFailed);
1141       }
1142     } else {
1143       result.AppendError("no platform is selected\n");
1144       result.SetStatus(eReturnStatusFailed);
1145     }
1146     return result.Succeeded();
1147   }
1148
1149   class CommandOptions : public Options {
1150   public:
1151     CommandOptions()
1152         : Options(), match_info(), show_args(false), verbose(false) {}
1153
1154     ~CommandOptions() override = default;
1155
1156     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1157                           ExecutionContext *execution_context) override {
1158       Status error;
1159       const int short_option = m_getopt_table[option_idx].val;
1160       bool success = false;
1161
1162       uint32_t id = LLDB_INVALID_PROCESS_ID;
1163       success = !option_arg.getAsInteger(0, id);
1164       switch (short_option) {
1165       case 'p': {
1166         match_info.GetProcessInfo().SetProcessID(id);
1167         if (!success)
1168           error.SetErrorStringWithFormat("invalid process ID string: '%s'",
1169                                          option_arg.str().c_str());
1170         break;
1171       }
1172       case 'P':
1173         match_info.GetProcessInfo().SetParentProcessID(id);
1174         if (!success)
1175           error.SetErrorStringWithFormat(
1176               "invalid parent process ID string: '%s'",
1177               option_arg.str().c_str());
1178         break;
1179
1180       case 'u':
1181         match_info.GetProcessInfo().SetUserID(success ? id : UINT32_MAX);
1182         if (!success)
1183           error.SetErrorStringWithFormat("invalid user ID string: '%s'",
1184                                          option_arg.str().c_str());
1185         break;
1186
1187       case 'U':
1188         match_info.GetProcessInfo().SetEffectiveUserID(success ? id
1189                                                                : UINT32_MAX);
1190         if (!success)
1191           error.SetErrorStringWithFormat(
1192               "invalid effective user ID string: '%s'",
1193               option_arg.str().c_str());
1194         break;
1195
1196       case 'g':
1197         match_info.GetProcessInfo().SetGroupID(success ? id : UINT32_MAX);
1198         if (!success)
1199           error.SetErrorStringWithFormat("invalid group ID string: '%s'",
1200                                          option_arg.str().c_str());
1201         break;
1202
1203       case 'G':
1204         match_info.GetProcessInfo().SetEffectiveGroupID(success ? id
1205                                                                 : UINT32_MAX);
1206         if (!success)
1207           error.SetErrorStringWithFormat(
1208               "invalid effective group ID string: '%s'",
1209               option_arg.str().c_str());
1210         break;
1211
1212       case 'a': {
1213         TargetSP target_sp =
1214             execution_context ? execution_context->GetTargetSP() : TargetSP();
1215         DebuggerSP debugger_sp =
1216             target_sp ? target_sp->GetDebugger().shared_from_this()
1217                       : DebuggerSP();
1218         PlatformSP platform_sp =
1219             debugger_sp ? debugger_sp->GetPlatformList().GetSelectedPlatform()
1220                         : PlatformSP();
1221         match_info.GetProcessInfo().GetArchitecture() =
1222             Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
1223       } break;
1224
1225       case 'n':
1226         match_info.GetProcessInfo().GetExecutableFile().SetFile(
1227             option_arg, FileSpec::Style::native);
1228         match_info.SetNameMatchType(NameMatch::Equals);
1229         break;
1230
1231       case 'e':
1232         match_info.GetProcessInfo().GetExecutableFile().SetFile(
1233             option_arg, FileSpec::Style::native);
1234         match_info.SetNameMatchType(NameMatch::EndsWith);
1235         break;
1236
1237       case 's':
1238         match_info.GetProcessInfo().GetExecutableFile().SetFile(
1239             option_arg, FileSpec::Style::native);
1240         match_info.SetNameMatchType(NameMatch::StartsWith);
1241         break;
1242
1243       case 'c':
1244         match_info.GetProcessInfo().GetExecutableFile().SetFile(
1245             option_arg, FileSpec::Style::native);
1246         match_info.SetNameMatchType(NameMatch::Contains);
1247         break;
1248
1249       case 'r':
1250         match_info.GetProcessInfo().GetExecutableFile().SetFile(
1251             option_arg, FileSpec::Style::native);
1252         match_info.SetNameMatchType(NameMatch::RegularExpression);
1253         break;
1254
1255       case 'A':
1256         show_args = true;
1257         break;
1258
1259       case 'v':
1260         verbose = true;
1261         break;
1262
1263       case 'x':
1264         match_info.SetMatchAllUsers(true);
1265         break;
1266
1267       default:
1268         llvm_unreachable("Unimplemented option");
1269       }
1270
1271       return error;
1272     }
1273
1274     void OptionParsingStarting(ExecutionContext *execution_context) override {
1275       match_info.Clear();
1276       show_args = false;
1277       verbose = false;
1278     }
1279
1280     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1281       return llvm::makeArrayRef(g_platform_process_list_options);
1282     }
1283
1284     // Instance variables to hold the values for command options.
1285
1286     ProcessInstanceInfoMatch match_info;
1287     bool show_args;
1288     bool verbose;
1289   };
1290
1291   CommandOptions m_options;
1292 };
1293
1294 // "platform process info"
1295 class CommandObjectPlatformProcessInfo : public CommandObjectParsed {
1296 public:
1297   CommandObjectPlatformProcessInfo(CommandInterpreter &interpreter)
1298       : CommandObjectParsed(
1299             interpreter, "platform process info",
1300             "Get detailed information for one or more process by process ID.",
1301             "platform process info <pid> [<pid> <pid> ...]", 0) {
1302     CommandArgumentEntry arg;
1303     CommandArgumentData pid_args;
1304
1305     // Define the first (and only) variant of this arg.
1306     pid_args.arg_type = eArgTypePid;
1307     pid_args.arg_repetition = eArgRepeatStar;
1308
1309     // There is only one variant this argument could be; put it into the
1310     // argument entry.
1311     arg.push_back(pid_args);
1312
1313     // Push the data for the first argument into the m_arguments vector.
1314     m_arguments.push_back(arg);
1315   }
1316
1317   ~CommandObjectPlatformProcessInfo() override = default;
1318
1319 protected:
1320   bool DoExecute(Args &args, CommandReturnObject &result) override {
1321     Target *target = GetDebugger().GetSelectedTarget().get();
1322     PlatformSP platform_sp;
1323     if (target) {
1324       platform_sp = target->GetPlatform();
1325     }
1326     if (!platform_sp) {
1327       platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform();
1328     }
1329
1330     if (platform_sp) {
1331       const size_t argc = args.GetArgumentCount();
1332       if (argc > 0) {
1333         Status error;
1334
1335         if (platform_sp->IsConnected()) {
1336           Stream &ostrm = result.GetOutputStream();
1337           for (auto &entry : args.entries()) {
1338             lldb::pid_t pid;
1339             if (entry.ref().getAsInteger(0, pid)) {
1340               result.AppendErrorWithFormat("invalid process ID argument '%s'",
1341                                            entry.ref().str().c_str());
1342               result.SetStatus(eReturnStatusFailed);
1343               break;
1344             } else {
1345               ProcessInstanceInfo proc_info;
1346               if (platform_sp->GetProcessInfo(pid, proc_info)) {
1347                 ostrm.Printf("Process information for process %" PRIu64 ":\n",
1348                              pid);
1349                 proc_info.Dump(ostrm, platform_sp->GetUserIDResolver());
1350               } else {
1351                 ostrm.Printf("error: no process information is available for "
1352                              "process %" PRIu64 "\n",
1353                              pid);
1354               }
1355               ostrm.EOL();
1356             }
1357           }
1358         } else {
1359           // Not connected...
1360           result.AppendErrorWithFormat(
1361               "not connected to '%s'",
1362               platform_sp->GetPluginName().GetCString());
1363           result.SetStatus(eReturnStatusFailed);
1364         }
1365       } else {
1366         // No args
1367         result.AppendError("one or more process id(s) must be specified");
1368         result.SetStatus(eReturnStatusFailed);
1369       }
1370     } else {
1371       result.AppendError("no platform is currently selected");
1372       result.SetStatus(eReturnStatusFailed);
1373     }
1374     return result.Succeeded();
1375   }
1376 };
1377
1378 #define LLDB_OPTIONS_platform_process_attach
1379 #include "CommandOptions.inc"
1380
1381 class CommandObjectPlatformProcessAttach : public CommandObjectParsed {
1382 public:
1383   class CommandOptions : public Options {
1384   public:
1385     CommandOptions() : Options() {
1386       // Keep default values of all options in one place: OptionParsingStarting
1387       // ()
1388       OptionParsingStarting(nullptr);
1389     }
1390
1391     ~CommandOptions() override = default;
1392
1393     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1394                           ExecutionContext *execution_context) override {
1395       Status error;
1396       char short_option = (char)m_getopt_table[option_idx].val;
1397       switch (short_option) {
1398       case 'p': {
1399         lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
1400         if (option_arg.getAsInteger(0, pid)) {
1401           error.SetErrorStringWithFormat("invalid process ID '%s'",
1402                                          option_arg.str().c_str());
1403         } else {
1404           attach_info.SetProcessID(pid);
1405         }
1406       } break;
1407
1408       case 'P':
1409         attach_info.SetProcessPluginName(option_arg);
1410         break;
1411
1412       case 'n':
1413         attach_info.GetExecutableFile().SetFile(option_arg,
1414                                                 FileSpec::Style::native);
1415         break;
1416
1417       case 'w':
1418         attach_info.SetWaitForLaunch(true);
1419         break;
1420
1421       default:
1422         llvm_unreachable("Unimplemented option");
1423       }
1424       return error;
1425     }
1426
1427     void OptionParsingStarting(ExecutionContext *execution_context) override {
1428       attach_info.Clear();
1429     }
1430
1431     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1432       return llvm::makeArrayRef(g_platform_process_attach_options);
1433     }
1434
1435     void HandleOptionArgumentCompletion(
1436         CompletionRequest &request, OptionElementVector &opt_element_vector,
1437         int opt_element_index, CommandInterpreter &interpreter) override {
1438       int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
1439       int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
1440
1441       // We are only completing the name option for now...
1442
1443       // Are we in the name?
1444       if (GetDefinitions()[opt_defs_index].short_option != 'n')
1445         return;
1446
1447       // Look to see if there is a -P argument provided, and if so use that
1448       // plugin, otherwise use the default plugin.
1449
1450       const char *partial_name = nullptr;
1451       partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos);
1452
1453       PlatformSP platform_sp(interpreter.GetPlatform(true));
1454       if (!platform_sp)
1455         return;
1456
1457       ProcessInstanceInfoList process_infos;
1458       ProcessInstanceInfoMatch match_info;
1459       if (partial_name) {
1460         match_info.GetProcessInfo().GetExecutableFile().SetFile(
1461             partial_name, FileSpec::Style::native);
1462         match_info.SetNameMatchType(NameMatch::StartsWith);
1463       }
1464       platform_sp->FindProcesses(match_info, process_infos);
1465       const uint32_t num_matches = process_infos.GetSize();
1466       if (num_matches == 0)
1467         return;
1468
1469       for (uint32_t i = 0; i < num_matches; ++i) {
1470         request.AddCompletion(process_infos.GetProcessNameAtIndex(i));
1471       }
1472       return;
1473     }
1474
1475     // Options table: Required for subclasses of Options.
1476
1477     static OptionDefinition g_option_table[];
1478
1479     // Instance variables to hold the values for command options.
1480
1481     ProcessAttachInfo attach_info;
1482   };
1483
1484   CommandObjectPlatformProcessAttach(CommandInterpreter &interpreter)
1485       : CommandObjectParsed(interpreter, "platform process attach",
1486                             "Attach to a process.",
1487                             "platform process attach <cmd-options>"),
1488         m_options() {}
1489
1490   ~CommandObjectPlatformProcessAttach() override = default;
1491
1492   bool DoExecute(Args &command, CommandReturnObject &result) override {
1493     PlatformSP platform_sp(
1494         GetDebugger().GetPlatformList().GetSelectedPlatform());
1495     if (platform_sp) {
1496       Status err;
1497       ProcessSP remote_process_sp = platform_sp->Attach(
1498           m_options.attach_info, GetDebugger(), nullptr, err);
1499       if (err.Fail()) {
1500         result.AppendError(err.AsCString());
1501         result.SetStatus(eReturnStatusFailed);
1502       } else if (!remote_process_sp) {
1503         result.AppendError("could not attach: unknown reason");
1504         result.SetStatus(eReturnStatusFailed);
1505       } else
1506         result.SetStatus(eReturnStatusSuccessFinishResult);
1507     } else {
1508       result.AppendError("no platform is currently selected");
1509       result.SetStatus(eReturnStatusFailed);
1510     }
1511     return result.Succeeded();
1512   }
1513
1514   Options *GetOptions() override { return &m_options; }
1515
1516 protected:
1517   CommandOptions m_options;
1518 };
1519
1520 class CommandObjectPlatformProcess : public CommandObjectMultiword {
1521 public:
1522   // Constructors and Destructors
1523   CommandObjectPlatformProcess(CommandInterpreter &interpreter)
1524       : CommandObjectMultiword(interpreter, "platform process",
1525                                "Commands to query, launch and attach to "
1526                                "processes on the current platform.",
1527                                "platform process [attach|launch|list] ...") {
1528     LoadSubCommand(
1529         "attach",
1530         CommandObjectSP(new CommandObjectPlatformProcessAttach(interpreter)));
1531     LoadSubCommand(
1532         "launch",
1533         CommandObjectSP(new CommandObjectPlatformProcessLaunch(interpreter)));
1534     LoadSubCommand("info", CommandObjectSP(new CommandObjectPlatformProcessInfo(
1535                                interpreter)));
1536     LoadSubCommand("list", CommandObjectSP(new CommandObjectPlatformProcessList(
1537                                interpreter)));
1538   }
1539
1540   ~CommandObjectPlatformProcess() override = default;
1541
1542 private:
1543   // For CommandObjectPlatform only
1544   DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess);
1545 };
1546
1547 // "platform shell"
1548 #define LLDB_OPTIONS_platform_shell
1549 #include "CommandOptions.inc"
1550
1551 class CommandObjectPlatformShell : public CommandObjectRaw {
1552 public:
1553   class CommandOptions : public Options {
1554   public:
1555     CommandOptions() : Options() {}
1556
1557     ~CommandOptions() override = default;
1558
1559     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1560       return llvm::makeArrayRef(g_platform_shell_options);
1561     }
1562
1563     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1564                           ExecutionContext *execution_context) override {
1565       Status error;
1566
1567       const char short_option = (char)GetDefinitions()[option_idx].short_option;
1568
1569       switch (short_option) {
1570       case 't':
1571         uint32_t timeout_sec;
1572         if (option_arg.getAsInteger(10, timeout_sec))
1573           error.SetErrorStringWithFormat(
1574               "could not convert \"%s\" to a numeric value.",
1575               option_arg.str().c_str());
1576         else
1577           timeout = std::chrono::seconds(timeout_sec);
1578         break;
1579       default:
1580         llvm_unreachable("Unimplemented option");
1581       }
1582
1583       return error;
1584     }
1585
1586     void OptionParsingStarting(ExecutionContext *execution_context) override {}
1587
1588     Timeout<std::micro> timeout = std::chrono::seconds(10);
1589   };
1590
1591   CommandObjectPlatformShell(CommandInterpreter &interpreter)
1592       : CommandObjectRaw(interpreter, "platform shell",
1593                          "Run a shell command on the current platform.",
1594                          "platform shell <shell-command>", 0),
1595         m_options() {}
1596
1597   ~CommandObjectPlatformShell() override = default;
1598
1599   Options *GetOptions() override { return &m_options; }
1600
1601   bool DoExecute(llvm::StringRef raw_command_line,
1602                  CommandReturnObject &result) override {
1603     ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext();
1604     m_options.NotifyOptionParsingStarting(&exe_ctx);
1605
1606     // Print out an usage syntax on an empty command line.
1607     if (raw_command_line.empty()) {
1608       result.GetOutputStream().Printf("%s\n", this->GetSyntax().str().c_str());
1609       return true;
1610     }
1611
1612     OptionsWithRaw args(raw_command_line);
1613     const char *expr = args.GetRawPart().c_str();
1614
1615     if (args.HasArgs())
1616       if (!ParseOptions(args.GetArgs(), result))
1617         return false;
1618
1619     PlatformSP platform_sp(
1620         GetDebugger().GetPlatformList().GetSelectedPlatform());
1621     Status error;
1622     if (platform_sp) {
1623       FileSpec working_dir{};
1624       std::string output;
1625       int status = -1;
1626       int signo = -1;
1627       error = (platform_sp->RunShellCommand(expr, working_dir, &status, &signo,
1628                                             &output, m_options.timeout));
1629       if (!output.empty())
1630         result.GetOutputStream().PutCString(output);
1631       if (status > 0) {
1632         if (signo > 0) {
1633           const char *signo_cstr = Host::GetSignalAsCString(signo);
1634           if (signo_cstr)
1635             result.GetOutputStream().Printf(
1636                 "error: command returned with status %i and signal %s\n",
1637                 status, signo_cstr);
1638           else
1639             result.GetOutputStream().Printf(
1640                 "error: command returned with status %i and signal %i\n",
1641                 status, signo);
1642         } else
1643           result.GetOutputStream().Printf(
1644               "error: command returned with status %i\n", status);
1645       }
1646     } else {
1647       result.GetOutputStream().Printf(
1648           "error: cannot run remote shell commands without a platform\n");
1649       error.SetErrorString(
1650           "error: cannot run remote shell commands without a platform");
1651     }
1652
1653     if (error.Fail()) {
1654       result.AppendError(error.AsCString());
1655       result.SetStatus(eReturnStatusFailed);
1656     } else {
1657       result.SetStatus(eReturnStatusSuccessFinishResult);
1658     }
1659     return true;
1660   }
1661
1662   CommandOptions m_options;
1663 };
1664
1665 // "platform install" - install a target to a remote end
1666 class CommandObjectPlatformInstall : public CommandObjectParsed {
1667 public:
1668   CommandObjectPlatformInstall(CommandInterpreter &interpreter)
1669       : CommandObjectParsed(
1670             interpreter, "platform target-install",
1671             "Install a target (bundle or executable file) to the remote end.",
1672             "platform target-install <local-thing> <remote-sandbox>", 0) {}
1673
1674   ~CommandObjectPlatformInstall() override = default;
1675
1676   bool DoExecute(Args &args, CommandReturnObject &result) override {
1677     if (args.GetArgumentCount() != 2) {
1678       result.AppendError("platform target-install takes two arguments");
1679       result.SetStatus(eReturnStatusFailed);
1680       return false;
1681     }
1682     // TODO: move the bulk of this code over to the platform itself
1683     FileSpec src(args.GetArgumentAtIndex(0));
1684     FileSystem::Instance().Resolve(src);
1685     FileSpec dst(args.GetArgumentAtIndex(1));
1686     if (!FileSystem::Instance().Exists(src)) {
1687       result.AppendError("source location does not exist or is not accessible");
1688       result.SetStatus(eReturnStatusFailed);
1689       return false;
1690     }
1691     PlatformSP platform_sp(
1692         GetDebugger().GetPlatformList().GetSelectedPlatform());
1693     if (!platform_sp) {
1694       result.AppendError("no platform currently selected");
1695       result.SetStatus(eReturnStatusFailed);
1696       return false;
1697     }
1698
1699     Status error = platform_sp->Install(src, dst);
1700     if (error.Success()) {
1701       result.SetStatus(eReturnStatusSuccessFinishNoResult);
1702     } else {
1703       result.AppendErrorWithFormat("install failed: %s", error.AsCString());
1704       result.SetStatus(eReturnStatusFailed);
1705     }
1706     return result.Succeeded();
1707   }
1708 };
1709
1710 CommandObjectPlatform::CommandObjectPlatform(CommandInterpreter &interpreter)
1711     : CommandObjectMultiword(
1712           interpreter, "platform", "Commands to manage and create platforms.",
1713           "platform [connect|disconnect|info|list|status|select] ...") {
1714   LoadSubCommand("select",
1715                  CommandObjectSP(new CommandObjectPlatformSelect(interpreter)));
1716   LoadSubCommand("list",
1717                  CommandObjectSP(new CommandObjectPlatformList(interpreter)));
1718   LoadSubCommand("status",
1719                  CommandObjectSP(new CommandObjectPlatformStatus(interpreter)));
1720   LoadSubCommand("connect", CommandObjectSP(
1721                                 new CommandObjectPlatformConnect(interpreter)));
1722   LoadSubCommand(
1723       "disconnect",
1724       CommandObjectSP(new CommandObjectPlatformDisconnect(interpreter)));
1725   LoadSubCommand("settings", CommandObjectSP(new CommandObjectPlatformSettings(
1726                                  interpreter)));
1727   LoadSubCommand("mkdir",
1728                  CommandObjectSP(new CommandObjectPlatformMkDir(interpreter)));
1729   LoadSubCommand("file",
1730                  CommandObjectSP(new CommandObjectPlatformFile(interpreter)));
1731   LoadSubCommand("get-file", CommandObjectSP(new CommandObjectPlatformGetFile(
1732                                  interpreter)));
1733   LoadSubCommand("get-size", CommandObjectSP(new CommandObjectPlatformGetSize(
1734                                  interpreter)));
1735   LoadSubCommand("put-file", CommandObjectSP(new CommandObjectPlatformPutFile(
1736                                  interpreter)));
1737   LoadSubCommand("process", CommandObjectSP(
1738                                 new CommandObjectPlatformProcess(interpreter)));
1739   LoadSubCommand("shell",
1740                  CommandObjectSP(new CommandObjectPlatformShell(interpreter)));
1741   LoadSubCommand(
1742       "target-install",
1743       CommandObjectSP(new CommandObjectPlatformInstall(interpreter)));
1744 }
1745
1746 CommandObjectPlatform::~CommandObjectPlatform() = default;