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