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