1 //===-- SBPlatform.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 "lldb/API/SBPlatform.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBError.h"
12 #include "lldb/API/SBFileSpec.h"
13 #include "lldb/API/SBLaunchInfo.h"
14 #include "lldb/API/SBUnixSignals.h"
15 #include "lldb/Host/File.h"
16 #include "lldb/Target/Platform.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Utility/ArchSpec.h"
19 #include "lldb/Utility/Args.h"
20 #include "lldb/Utility/Status.h"
21 
22 #include "llvm/Support/FileSystem.h"
23 
24 #include <functional>
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 // PlatformConnectOptions
30 struct PlatformConnectOptions {
31   PlatformConnectOptions(const char *url = nullptr)
32       : m_url(), m_rsync_options(), m_rsync_remote_path_prefix(),
33         m_rsync_enabled(false), m_rsync_omit_hostname_from_remote_path(false),
34         m_local_cache_directory() {
35     if (url && url[0])
36       m_url = url;
37   }
38 
39   ~PlatformConnectOptions() {}
40 
41   std::string m_url;
42   std::string m_rsync_options;
43   std::string m_rsync_remote_path_prefix;
44   bool m_rsync_enabled;
45   bool m_rsync_omit_hostname_from_remote_path;
46   ConstString m_local_cache_directory;
47 };
48 
49 // PlatformShellCommand
50 struct PlatformShellCommand {
51   PlatformShellCommand(const char *shell_command = nullptr)
52       : m_command(), m_working_dir(), m_status(0), m_signo(0) {
53     if (shell_command && shell_command[0])
54       m_command = shell_command;
55   }
56 
57   ~PlatformShellCommand() {}
58 
59   std::string m_command;
60   std::string m_working_dir;
61   std::string m_output;
62   int m_status;
63   int m_signo;
64   Timeout<std::ratio<1>> m_timeout = llvm::None;
65 };
66 // SBPlatformConnectOptions
67 SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
68     : m_opaque_ptr(new PlatformConnectOptions(url)) {
69   LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
70 }
71 
72 SBPlatformConnectOptions::SBPlatformConnectOptions(
73     const SBPlatformConnectOptions &rhs)
74     : m_opaque_ptr(new PlatformConnectOptions()) {
75   LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions,
76                           (const lldb::SBPlatformConnectOptions &), rhs);
77 
78   *m_opaque_ptr = *rhs.m_opaque_ptr;
79 }
80 
81 SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
82 
83 void SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
84   LLDB_RECORD_METHOD(
85       void,
86       SBPlatformConnectOptions, operator=,(
87                                     const lldb::SBPlatformConnectOptions &),
88       rhs);
89 
90   *m_opaque_ptr = *rhs.m_opaque_ptr;
91 }
92 
93 const char *SBPlatformConnectOptions::GetURL() {
94   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL);
95 
96   if (m_opaque_ptr->m_url.empty())
97     return nullptr;
98   return m_opaque_ptr->m_url.c_str();
99 }
100 
101 void SBPlatformConnectOptions::SetURL(const char *url) {
102   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
103                      url);
104 
105   if (url && url[0])
106     m_opaque_ptr->m_url = url;
107   else
108     m_opaque_ptr->m_url.clear();
109 }
110 
111 bool SBPlatformConnectOptions::GetRsyncEnabled() {
112   LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
113 
114   return m_opaque_ptr->m_rsync_enabled;
115 }
116 
117 void SBPlatformConnectOptions::EnableRsync(
118     const char *options, const char *remote_path_prefix,
119     bool omit_hostname_from_remote_path) {
120   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
121                      (const char *, const char *, bool), options,
122                      remote_path_prefix, omit_hostname_from_remote_path);
123 
124   m_opaque_ptr->m_rsync_enabled = true;
125   m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
126       omit_hostname_from_remote_path;
127   if (remote_path_prefix && remote_path_prefix[0])
128     m_opaque_ptr->m_rsync_remote_path_prefix = remote_path_prefix;
129   else
130     m_opaque_ptr->m_rsync_remote_path_prefix.clear();
131 
132   if (options && options[0])
133     m_opaque_ptr->m_rsync_options = options;
134   else
135     m_opaque_ptr->m_rsync_options.clear();
136 }
137 
138 void SBPlatformConnectOptions::DisableRsync() {
139   LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync);
140 
141   m_opaque_ptr->m_rsync_enabled = false;
142 }
143 
144 const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
145   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions,
146                              GetLocalCacheDirectory);
147 
148   return m_opaque_ptr->m_local_cache_directory.GetCString();
149 }
150 
151 void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
152   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
153                      (const char *), path);
154 
155   if (path && path[0])
156     m_opaque_ptr->m_local_cache_directory.SetCString(path);
157   else
158     m_opaque_ptr->m_local_cache_directory = ConstString();
159 }
160 
161 // SBPlatformShellCommand
162 SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
163     : m_opaque_ptr(new PlatformShellCommand(shell_command)) {
164   LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
165                           shell_command);
166 }
167 
168 SBPlatformShellCommand::SBPlatformShellCommand(
169     const SBPlatformShellCommand &rhs)
170     : m_opaque_ptr(new PlatformShellCommand()) {
171   LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand,
172                           (const lldb::SBPlatformShellCommand &), rhs);
173 
174   *m_opaque_ptr = *rhs.m_opaque_ptr;
175 }
176 
177 SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
178 
179 void SBPlatformShellCommand::Clear() {
180   LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear);
181 
182   m_opaque_ptr->m_output = std::string();
183   m_opaque_ptr->m_status = 0;
184   m_opaque_ptr->m_signo = 0;
185 }
186 
187 const char *SBPlatformShellCommand::GetCommand() {
188   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
189 
190   if (m_opaque_ptr->m_command.empty())
191     return nullptr;
192   return m_opaque_ptr->m_command.c_str();
193 }
194 
195 void SBPlatformShellCommand::SetCommand(const char *shell_command) {
196   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
197                      shell_command);
198 
199   if (shell_command && shell_command[0])
200     m_opaque_ptr->m_command = shell_command;
201   else
202     m_opaque_ptr->m_command.clear();
203 }
204 
205 const char *SBPlatformShellCommand::GetWorkingDirectory() {
206   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
207                              GetWorkingDirectory);
208 
209   if (m_opaque_ptr->m_working_dir.empty())
210     return nullptr;
211   return m_opaque_ptr->m_working_dir.c_str();
212 }
213 
214 void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
215   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
216                      (const char *), path);
217 
218   if (path && path[0])
219     m_opaque_ptr->m_working_dir = path;
220   else
221     m_opaque_ptr->m_working_dir.clear();
222 }
223 
224 uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
225   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
226                              GetTimeoutSeconds);
227 
228   if (m_opaque_ptr->m_timeout)
229     return m_opaque_ptr->m_timeout->count();
230   return UINT32_MAX;
231 }
232 
233 void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
234   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
235                      (uint32_t), sec);
236 
237   if (sec == UINT32_MAX)
238     m_opaque_ptr->m_timeout = llvm::None;
239   else
240     m_opaque_ptr->m_timeout = std::chrono::seconds(sec);
241 }
242 
243 int SBPlatformShellCommand::GetSignal() {
244   LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal);
245 
246   return m_opaque_ptr->m_signo;
247 }
248 
249 int SBPlatformShellCommand::GetStatus() {
250   LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
251 
252   return m_opaque_ptr->m_status;
253 }
254 
255 const char *SBPlatformShellCommand::GetOutput() {
256   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
257 
258   if (m_opaque_ptr->m_output.empty())
259     return nullptr;
260   return m_opaque_ptr->m_output.c_str();
261 }
262 
263 // SBPlatform
264 SBPlatform::SBPlatform() : m_opaque_sp() {
265   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform);
266 }
267 
268 SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
269   LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name);
270 
271   Status error;
272   if (platform_name && platform_name[0])
273     m_opaque_sp = Platform::Create(ConstString(platform_name), error);
274 }
275 
276 SBPlatform::~SBPlatform() {}
277 
278 bool SBPlatform::IsValid() const {
279   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
280   return this->operator bool();
281 }
282 SBPlatform::operator bool() const {
283   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
284 
285   return m_opaque_sp.get() != nullptr;
286 }
287 
288 void SBPlatform::Clear() {
289   LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
290 
291   m_opaque_sp.reset();
292 }
293 
294 const char *SBPlatform::GetName() {
295   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName);
296 
297   PlatformSP platform_sp(GetSP());
298   if (platform_sp)
299     return platform_sp->GetName().GetCString();
300   return nullptr;
301 }
302 
303 lldb::PlatformSP SBPlatform::GetSP() const { return m_opaque_sp; }
304 
305 void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
306   m_opaque_sp = platform_sp;
307 }
308 
309 const char *SBPlatform::GetWorkingDirectory() {
310   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
311 
312   PlatformSP platform_sp(GetSP());
313   if (platform_sp)
314     return platform_sp->GetWorkingDirectory().GetCString();
315   return nullptr;
316 }
317 
318 bool SBPlatform::SetWorkingDirectory(const char *path) {
319   LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
320                      path);
321 
322   PlatformSP platform_sp(GetSP());
323   if (platform_sp) {
324     if (path)
325       platform_sp->SetWorkingDirectory(FileSpec(path));
326     else
327       platform_sp->SetWorkingDirectory(FileSpec());
328     return true;
329   }
330   return false;
331 }
332 
333 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
334   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
335                      (lldb::SBPlatformConnectOptions &), connect_options);
336 
337   SBError sb_error;
338   PlatformSP platform_sp(GetSP());
339   if (platform_sp && connect_options.GetURL()) {
340     Args args;
341     args.AppendArgument(
342         llvm::StringRef::withNullAsEmpty(connect_options.GetURL()));
343     sb_error.ref() = platform_sp->ConnectRemote(args);
344   } else {
345     sb_error.SetErrorString("invalid platform");
346   }
347   return LLDB_RECORD_RESULT(sb_error);
348 }
349 
350 void SBPlatform::DisconnectRemote() {
351   LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
352 
353   PlatformSP platform_sp(GetSP());
354   if (platform_sp)
355     platform_sp->DisconnectRemote();
356 }
357 
358 bool SBPlatform::IsConnected() {
359   LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
360 
361   PlatformSP platform_sp(GetSP());
362   if (platform_sp)
363     return platform_sp->IsConnected();
364   return false;
365 }
366 
367 const char *SBPlatform::GetTriple() {
368   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
369 
370   PlatformSP platform_sp(GetSP());
371   if (platform_sp) {
372     ArchSpec arch(platform_sp->GetSystemArchitecture());
373     if (arch.IsValid()) {
374       // Const-ify the string so we don't need to worry about the lifetime of
375       // the string
376       return ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
377     }
378   }
379   return nullptr;
380 }
381 
382 const char *SBPlatform::GetOSBuild() {
383   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
384 
385   PlatformSP platform_sp(GetSP());
386   if (platform_sp) {
387     std::string s;
388     if (platform_sp->GetOSBuildString(s)) {
389       if (!s.empty()) {
390         // Const-ify the string so we don't need to worry about the lifetime of
391         // the string
392         return ConstString(s.c_str()).GetCString();
393       }
394     }
395   }
396   return nullptr;
397 }
398 
399 const char *SBPlatform::GetOSDescription() {
400   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
401 
402   PlatformSP platform_sp(GetSP());
403   if (platform_sp) {
404     std::string s;
405     if (platform_sp->GetOSKernelDescription(s)) {
406       if (!s.empty()) {
407         // Const-ify the string so we don't need to worry about the lifetime of
408         // the string
409         return ConstString(s.c_str()).GetCString();
410       }
411     }
412   }
413   return nullptr;
414 }
415 
416 const char *SBPlatform::GetHostname() {
417   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
418 
419   PlatformSP platform_sp(GetSP());
420   if (platform_sp)
421     return platform_sp->GetHostname();
422   return nullptr;
423 }
424 
425 uint32_t SBPlatform::GetOSMajorVersion() {
426   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
427 
428   llvm::VersionTuple version;
429   if (PlatformSP platform_sp = GetSP())
430     version = platform_sp->GetOSVersion();
431   return version.empty() ? UINT32_MAX : version.getMajor();
432 }
433 
434 uint32_t SBPlatform::GetOSMinorVersion() {
435   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
436 
437   llvm::VersionTuple version;
438   if (PlatformSP platform_sp = GetSP())
439     version = platform_sp->GetOSVersion();
440   return version.getMinor().getValueOr(UINT32_MAX);
441 }
442 
443 uint32_t SBPlatform::GetOSUpdateVersion() {
444   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
445 
446   llvm::VersionTuple version;
447   if (PlatformSP platform_sp = GetSP())
448     version = platform_sp->GetOSVersion();
449   return version.getSubminor().getValueOr(UINT32_MAX);
450 }
451 
452 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
453   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
454                      (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
455 
456   SBError sb_error;
457   PlatformSP platform_sp(GetSP());
458   if (platform_sp) {
459     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
460   } else {
461     sb_error.SetErrorString("invalid platform");
462   }
463   return LLDB_RECORD_RESULT(sb_error);
464 }
465 
466 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
467   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
468                      (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
469   return LLDB_RECORD_RESULT(
470       ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
471         if (src.Exists()) {
472           uint32_t permissions =
473               FileSystem::Instance().GetPermissions(src.ref());
474           if (permissions == 0) {
475             if (FileSystem::Instance().IsDirectory(src.ref()))
476               permissions = eFilePermissionsDirectoryDefault;
477             else
478               permissions = eFilePermissionsFileDefault;
479           }
480 
481           return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
482         }
483 
484         Status error;
485         error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
486                                        src.ref().GetPath().c_str());
487         return error;
488       }));
489 }
490 
491 SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
492   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
493                      (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
494   return LLDB_RECORD_RESULT(
495       ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
496         if (src.Exists())
497           return platform_sp->Install(src.ref(), dst.ref());
498 
499         Status error;
500         error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
501                                        src.ref().GetPath().c_str());
502         return error;
503       }));
504 }
505 
506 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
507   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
508                      (lldb::SBPlatformShellCommand &), shell_command);
509   return LLDB_RECORD_RESULT(ExecuteConnected([&](const lldb::PlatformSP
510                                                      &platform_sp) {
511     const char *command = shell_command.GetCommand();
512     if (!command)
513       return Status("invalid shell command (empty)");
514 
515     const char *working_dir = shell_command.GetWorkingDirectory();
516     if (working_dir == nullptr) {
517       working_dir = platform_sp->GetWorkingDirectory().GetCString();
518       if (working_dir)
519         shell_command.SetWorkingDirectory(working_dir);
520     }
521     return platform_sp->RunShellCommand(command, FileSpec(working_dir),
522                                         &shell_command.m_opaque_ptr->m_status,
523                                         &shell_command.m_opaque_ptr->m_signo,
524                                         &shell_command.m_opaque_ptr->m_output,
525                                         shell_command.m_opaque_ptr->m_timeout);
526   }));
527 }
528 
529 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
530   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
531                      launch_info);
532   return LLDB_RECORD_RESULT(
533       ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
534         ProcessLaunchInfo info = launch_info.ref();
535         Status error = platform_sp->LaunchProcess(info);
536         launch_info.set_ref(info);
537         return error;
538       }));
539 }
540 
541 SBError SBPlatform::Kill(const lldb::pid_t pid) {
542   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
543   return LLDB_RECORD_RESULT(
544       ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
545         return platform_sp->KillProcess(pid);
546       }));
547 }
548 
549 SBError SBPlatform::ExecuteConnected(
550     const std::function<Status(const lldb::PlatformSP &)> &func) {
551   SBError sb_error;
552   const auto platform_sp(GetSP());
553   if (platform_sp) {
554     if (platform_sp->IsConnected())
555       sb_error.ref() = func(platform_sp);
556     else
557       sb_error.SetErrorString("not connected");
558   } else
559     sb_error.SetErrorString("invalid platform");
560 
561   return sb_error;
562 }
563 
564 SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
565   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
566                      (const char *, uint32_t), path, file_permissions);
567 
568   SBError sb_error;
569   PlatformSP platform_sp(GetSP());
570   if (platform_sp) {
571     sb_error.ref() =
572         platform_sp->MakeDirectory(FileSpec(path), file_permissions);
573   } else {
574     sb_error.SetErrorString("invalid platform");
575   }
576   return LLDB_RECORD_RESULT(sb_error);
577 }
578 
579 uint32_t SBPlatform::GetFilePermissions(const char *path) {
580   LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
581                      path);
582 
583   PlatformSP platform_sp(GetSP());
584   if (platform_sp) {
585     uint32_t file_permissions = 0;
586     platform_sp->GetFilePermissions(FileSpec(path), file_permissions);
587     return file_permissions;
588   }
589   return 0;
590 }
591 
592 SBError SBPlatform::SetFilePermissions(const char *path,
593                                        uint32_t file_permissions) {
594   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
595                      (const char *, uint32_t), path, file_permissions);
596 
597   SBError sb_error;
598   PlatformSP platform_sp(GetSP());
599   if (platform_sp) {
600     sb_error.ref() =
601         platform_sp->SetFilePermissions(FileSpec(path), file_permissions);
602   } else {
603     sb_error.SetErrorString("invalid platform");
604   }
605   return LLDB_RECORD_RESULT(sb_error);
606 }
607 
608 SBUnixSignals SBPlatform::GetUnixSignals() const {
609   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
610                                    GetUnixSignals);
611 
612   if (auto platform_sp = GetSP())
613     return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
614 
615   return LLDB_RECORD_RESULT(SBUnixSignals());
616 }
617 
618 namespace lldb_private {
619 namespace repro {
620 
621 template <>
622 void RegisterMethods<SBPlatformConnectOptions>(Registry &R) {
623   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
624   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
625                             (const lldb::SBPlatformConnectOptions &));
626   LLDB_REGISTER_METHOD(
627       void,
628       SBPlatformConnectOptions, operator=,(
629                                     const lldb::SBPlatformConnectOptions &));
630   LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
631   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL,
632                        (const char *));
633   LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
634   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
635                        (const char *, const char *, bool));
636   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
637   LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
638                        GetLocalCacheDirectory, ());
639   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
640                        (const char *));
641 }
642 
643 template <>
644 void RegisterMethods<SBPlatformShellCommand>(Registry &R) {
645   LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
646   LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
647                             (const lldb::SBPlatformShellCommand &));
648   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
649   LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
650   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
651                        (const char *));
652   LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
653                        GetWorkingDirectory, ());
654   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
655                        (const char *));
656   LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds,
657                        ());
658   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
659                        (uint32_t));
660   LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
661   LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
662   LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
663 }
664 
665 template <>
666 void RegisterMethods<SBPlatform>(Registry &R) {
667   LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
668   LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
669   LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
670   LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ());
671   LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
672   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
673   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
674   LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
675   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
676                        (lldb::SBPlatformConnectOptions &));
677   LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
678   LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
679   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
680   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
681   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
682   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
683   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
684   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
685   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
686   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
687                        (lldb::SBFileSpec &, lldb::SBFileSpec &));
688   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
689                        (lldb::SBFileSpec &, lldb::SBFileSpec &));
690   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
691                        (lldb::SBFileSpec &, lldb::SBFileSpec &));
692   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
693                        (lldb::SBPlatformShellCommand &));
694   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
695                        (lldb::SBLaunchInfo &));
696   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
697   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
698                        (const char *, uint32_t));
699   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
700                        (const char *));
701   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
702                        (const char *, uint32_t));
703   LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
704                              ());
705 }
706 
707 }
708 }
709