contrib/llvm/tools/lldb/source/Host/common/Host.cpp

   1 //===-- Host.cpp ------------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C includes
  11 #include <errno.h>
  12 #include <limits.h>
  13 #include <stdlib.h>
  14 #include <sys/types.h>
  15 #ifndef _WIN32
  16 #include <dlfcn.h>
  17 #include <grp.h>
  18 #include <netdb.h>
  19 #include <pwd.h>
  20 #include <sys/stat.h>
  21 #include <unistd.h>
  22 #endif
  23
  24 #if defined(__APPLE__)
  25 #include <mach-o/dyld.h>
  26 #include <mach/mach_init.h>
  27 #include <mach/mach_port.h>
  28 #endif
  29
  30 #if defined(__linux__) || defined(__FreeBSD__) ||                              \
  31     defined(__FreeBSD_kernel__) || defined(__APPLE__) ||                       \
  32     defined(__NetBSD__) || defined(__OpenBSD__)
  33 #if !defined(__ANDROID__)
  34 #include <spawn.h>
  35 #endif
  36 #include <sys/syscall.h>
  37 #include <sys/wait.h>
  38 #endif
  39
  40 #if defined(__FreeBSD__)
  41 #include <pthread_np.h>
  42 #endif
  43
  44 #if defined(__NetBSD__)
  45 #include <lwp.h>
  46 #endif
  47
  48 // C++ Includes
  49 #include <csignal>
  50
  51 // Other libraries and framework includes
  52 // Project includes
  53
  54 #include "lldb/Core/ArchSpec.h"
  55 #include "lldb/Host/Host.h"
  56 #include "lldb/Host/HostInfo.h"
  57 #include "lldb/Host/HostProcess.h"
  58 #include "lldb/Host/MonitoringProcessLauncher.h"
  59 #include "lldb/Host/Predicate.h"
  60 #include "lldb/Host/ProcessLauncher.h"
  61 #include "lldb/Host/ThreadLauncher.h"
  62 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
  63 #include "lldb/Target/FileAction.h"
  64 #include "lldb/Target/ProcessLaunchInfo.h"
  65 #include "lldb/Target/UnixSignals.h"
  66 #include "lldb/Utility/CleanUp.h"
  67 #include "lldb/Utility/DataBufferLLVM.h"
  68 #include "lldb/Utility/FileSpec.h"
  69 #include "lldb/Utility/Log.h"
  70 #include "lldb/Utility/Status.h"
  71 #include "lldb/lldb-private-forward.h"
  72 #include "llvm/ADT/SmallString.h"
  73 #include "llvm/ADT/StringSwitch.h"
  74 #include "llvm/Support/Errno.h"
  75 #include "llvm/Support/FileSystem.h"
  76
  77 #if defined(_WIN32)
  78 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
  79 #include "lldb/Host/windows/ProcessLauncherWindows.h"
  80 #else
  81 #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
  82 #endif
  83
  84 #if defined(__APPLE__)
  85 #ifndef _POSIX_SPAWN_DISABLE_ASLR
  86 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
  87 #endif
  88
  89 extern "C" {
  90 int __pthread_chdir(const char *path);
  91 int __pthread_fchdir(int fildes);
  92 }
  93
  94 #endif
  95
  96 using namespace lldb;
  97 using namespace lldb_private;
  98
  99 #if !defined(__APPLE__) && !defined(_WIN32)
 100 struct MonitorInfo {
 101   lldb::pid_t pid; // The process ID to monitor
 102   Host::MonitorChildProcessCallback
 103       callback; // The callback function to call when "pid" exits or signals
 104   bool monitor_signals; // If true, call the callback when "pid" gets signaled.
 105 };
 106
 107 static thread_result_t MonitorChildProcessThreadFunction(void *arg);
 108
 109 HostThread Host::StartMonitoringChildProcess(
 110     const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
 111     bool monitor_signals) {
 112   MonitorInfo *info_ptr = new MonitorInfo();
 113
 114   info_ptr->pid = pid;
 115   info_ptr->callback = callback;
 116   info_ptr->monitor_signals = monitor_signals;
 117
 118   char thread_name[256];
 119   ::snprintf(thread_name, sizeof(thread_name),
 120              "<lldb.host.wait4(pid=%" PRIu64 ")>", pid);
 121   return ThreadLauncher::LaunchThread(
 122       thread_name, MonitorChildProcessThreadFunction, info_ptr, NULL);
 123 }
 124
 125 #ifndef __linux__
 126 //------------------------------------------------------------------
 127 // Scoped class that will disable thread canceling when it is
 128 // constructed, and exception safely restore the previous value it
 129 // when it goes out of scope.
 130 //------------------------------------------------------------------
 131 class ScopedPThreadCancelDisabler {
 132 public:
 133   ScopedPThreadCancelDisabler() {
 134     // Disable the ability for this thread to be cancelled
 135     int err = ::pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &m_old_state);
 136     if (err != 0)
 137       m_old_state = -1;
 138   }
 139
 140   ~ScopedPThreadCancelDisabler() {
 141     // Restore the ability for this thread to be cancelled to what it
 142     // previously was.
 143     if (m_old_state != -1)
 144       ::pthread_setcancelstate(m_old_state, 0);
 145   }
 146
 147 private:
 148   int m_old_state; // Save the old cancelability state.
 149 };
 150 #endif // __linux__
 151
 152 #ifdef __linux__
 153 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
 154 static __thread volatile sig_atomic_t g_usr1_called;
 155 #else
 156 static thread_local volatile sig_atomic_t g_usr1_called;
 157 #endif
 158
 159 static void SigUsr1Handler(int) { g_usr1_called = 1; }
 160 #endif // __linux__
 161
 162 static bool CheckForMonitorCancellation() {
 163 #ifdef __linux__
 164   if (g_usr1_called) {
 165     g_usr1_called = 0;
 166     return true;
 167   }
 168 #else
 169   ::pthread_testcancel();
 170 #endif
 171   return false;
 172 }
 173
 174 static thread_result_t MonitorChildProcessThreadFunction(void *arg) {
 175   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 176   const char *function = __FUNCTION__;
 177   if (log)
 178     log->Printf("%s (arg = %p) thread starting...", function, arg);
 179
 180   MonitorInfo *info = (MonitorInfo *)arg;
 181
 182   const Host::MonitorChildProcessCallback callback = info->callback;
 183   const bool monitor_signals = info->monitor_signals;
 184
 185   assert(info->pid <= UINT32_MAX);
 186   const ::pid_t pid = monitor_signals ? -1 * getpgid(info->pid) : info->pid;
 187
 188   delete info;
 189
 190   int status = -1;
 191 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
 192 #define __WALL 0
 193 #endif
 194   const int options = __WALL;
 195
 196 #ifdef __linux__
 197   // This signal is only used to interrupt the thread from waitpid
 198   struct sigaction sigUsr1Action;
 199   memset(&sigUsr1Action, 0, sizeof(sigUsr1Action));
 200   sigUsr1Action.sa_handler = SigUsr1Handler;
 201   ::sigaction(SIGUSR1, &sigUsr1Action, nullptr);
 202 #endif // __linux__
 203
 204   while (1) {
 205     log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
 206     if (log)
 207       log->Printf("%s ::waitpid (pid = %" PRIi32 ", &status, options = %i)...",
 208                   function, pid, options);
 209
 210     if (CheckForMonitorCancellation())
 211       break;
 212
 213     // Get signals from all children with same process group of pid
 214     const ::pid_t wait_pid = ::waitpid(pid, &status, options);
 215
 216     if (CheckForMonitorCancellation())
 217       break;
 218
 219     if (wait_pid == -1) {
 220       if (errno == EINTR)
 221         continue;
 222       else {
 223         LLDB_LOG(log,
 224                  "arg = {0}, thread exiting because waitpid failed ({1})...",
 225                  arg, llvm::sys::StrError());
 226         break;
 227       }
 228     } else if (wait_pid > 0) {
 229       bool exited = false;
 230       int signal = 0;
 231       int exit_status = 0;
 232       const char *status_cstr = NULL;
 233       if (WIFSTOPPED(status)) {
 234         signal = WSTOPSIG(status);
 235         status_cstr = "STOPPED";
 236       } else if (WIFEXITED(status)) {
 237         exit_status = WEXITSTATUS(status);
 238         status_cstr = "EXITED";
 239         exited = true;
 240       } else if (WIFSIGNALED(status)) {
 241         signal = WTERMSIG(status);
 242         status_cstr = "SIGNALED";
 243         if (wait_pid == abs(pid)) {
 244           exited = true;
 245           exit_status = -1;
 246         }
 247       } else {
 248         status_cstr = "(\?\?\?)";
 249       }
 250
 251       // Scope for pthread_cancel_disabler
 252       {
 253 #ifndef __linux__
 254         ScopedPThreadCancelDisabler pthread_cancel_disabler;
 255 #endif
 256
 257         log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
 258         if (log)
 259           log->Printf("%s ::waitpid (pid = %" PRIi32
 260                       ", &status, options = %i) => pid = %" PRIi32
 261                       ", status = 0x%8.8x (%s), signal = %i, exit_state = %i",
 262                       function, pid, options, wait_pid, status, status_cstr,
 263                       signal, exit_status);
 264
 265         if (exited || (signal != 0 && monitor_signals)) {
 266           bool callback_return = false;
 267           if (callback)
 268             callback_return = callback(wait_pid, exited, signal, exit_status);
 269
 270           // If our process exited, then this thread should exit
 271           if (exited && wait_pid == abs(pid)) {
 272             if (log)
 273               log->Printf("%s (arg = %p) thread exiting because pid received "
 274                           "exit signal...",
 275                           __FUNCTION__, arg);
 276             break;
 277           }
 278           // If the callback returns true, it means this process should
 279           // exit
 280           if (callback_return) {
 281             if (log)
 282               log->Printf("%s (arg = %p) thread exiting because callback "
 283                           "returned true...",
 284                           __FUNCTION__, arg);
 285             break;
 286           }
 287         }
 288       }
 289     }
 290   }
 291
 292   log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
 293   if (log)
 294     log->Printf("%s (arg = %p) thread exiting...", __FUNCTION__, arg);
 295
 296   return NULL;
 297 }
 298
 299 #endif // #if !defined (__APPLE__) && !defined (_WIN32)
 300
 301 #if !defined(__APPLE__)
 302
 303 void Host::SystemLog(SystemLogType type, const char *format, va_list args) {
 304   vfprintf(stderr, format, args);
 305 }
 306
 307 #endif
 308
 309 void Host::SystemLog(SystemLogType type, const char *format, ...) {
 310   va_list args;
 311   va_start(args, format);
 312   SystemLog(type, format, args);
 313   va_end(args);
 314 }
 315
 316 lldb::pid_t Host::GetCurrentProcessID() { return ::getpid(); }
 317
 318 #ifndef _WIN32
 319
 320 lldb::thread_t Host::GetCurrentThread() {
 321   return lldb::thread_t(pthread_self());
 322 }
 323
 324 const char *Host::GetSignalAsCString(int signo) {
 325   switch (signo) {
 326   case SIGHUP:
 327     return "SIGHUP"; // 1    hangup
 328   case SIGINT:
 329     return "SIGINT"; // 2    interrupt
 330   case SIGQUIT:
 331     return "SIGQUIT"; // 3    quit
 332   case SIGILL:
 333     return "SIGILL"; // 4    illegal instruction (not reset when caught)
 334   case SIGTRAP:
 335     return "SIGTRAP"; // 5    trace trap (not reset when caught)
 336   case SIGABRT:
 337     return "SIGABRT"; // 6    abort()
 338 #if defined(SIGPOLL)
 339 #if !defined(SIGIO) || (SIGPOLL != SIGIO)
 340   // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the build to
 341   // fail with 'multiple define cases with same value'
 342   case SIGPOLL:
 343     return "SIGPOLL"; // 7    pollable event ([XSR] generated, not supported)
 344 #endif
 345 #endif
 346 #if defined(SIGEMT)
 347   case SIGEMT:
 348     return "SIGEMT"; // 7    EMT instruction
 349 #endif
 350   case SIGFPE:
 351     return "SIGFPE"; // 8    floating point exception
 352   case SIGKILL:
 353     return "SIGKILL"; // 9    kill (cannot be caught or ignored)
 354   case SIGBUS:
 355     return "SIGBUS"; // 10    bus error
 356   case SIGSEGV:
 357     return "SIGSEGV"; // 11    segmentation violation
 358   case SIGSYS:
 359     return "SIGSYS"; // 12    bad argument to system call
 360   case SIGPIPE:
 361     return "SIGPIPE"; // 13    write on a pipe with no one to read it
 362   case SIGALRM:
 363     return "SIGALRM"; // 14    alarm clock
 364   case SIGTERM:
 365     return "SIGTERM"; // 15    software termination signal from kill
 366   case SIGURG:
 367     return "SIGURG"; // 16    urgent condition on IO channel
 368   case SIGSTOP:
 369     return "SIGSTOP"; // 17    sendable stop signal not from tty
 370   case SIGTSTP:
 371     return "SIGTSTP"; // 18    stop signal from tty
 372   case SIGCONT:
 373     return "SIGCONT"; // 19    continue a stopped process
 374   case SIGCHLD:
 375     return "SIGCHLD"; // 20    to parent on child stop or exit
 376   case SIGTTIN:
 377     return "SIGTTIN"; // 21    to readers pgrp upon background tty read
 378   case SIGTTOU:
 379     return "SIGTTOU"; // 22    like TTIN for output if (tp->t_local&LTOSTOP)
 380 #if defined(SIGIO)
 381   case SIGIO:
 382     return "SIGIO"; // 23    input/output possible signal
 383 #endif
 384   case SIGXCPU:
 385     return "SIGXCPU"; // 24    exceeded CPU time limit
 386   case SIGXFSZ:
 387     return "SIGXFSZ"; // 25    exceeded file size limit
 388   case SIGVTALRM:
 389     return "SIGVTALRM"; // 26    virtual time alarm
 390   case SIGPROF:
 391     return "SIGPROF"; // 27    profiling time alarm
 392 #if defined(SIGWINCH)
 393   case SIGWINCH:
 394     return "SIGWINCH"; // 28    window size changes
 395 #endif
 396 #if defined(SIGINFO)
 397   case SIGINFO:
 398     return "SIGINFO"; // 29    information request
 399 #endif
 400   case SIGUSR1:
 401     return "SIGUSR1"; // 30    user defined signal 1
 402   case SIGUSR2:
 403     return "SIGUSR2"; // 31    user defined signal 2
 404   default:
 405     break;
 406   }
 407   return NULL;
 408 }
 409
 410 #endif
 411
 412 #if !defined(__APPLE__) // see Host.mm
 413
 414 bool Host::GetBundleDirectory(const FileSpec &file, FileSpec &bundle) {
 415   bundle.Clear();
 416   return false;
 417 }
 418
 419 bool Host::ResolveExecutableInBundle(FileSpec &file) { return false; }
 420 #endif
 421
 422 #ifndef _WIN32
 423
 424 FileSpec Host::GetModuleFileSpecForHostAddress(const void *host_addr) {
 425   FileSpec module_filespec;
 426 #if !defined(__ANDROID__)
 427   Dl_info info;
 428   if (::dladdr(host_addr, &info)) {
 429     if (info.dli_fname)
 430       module_filespec.SetFile(info.dli_fname, true);
 431   }
 432 #endif
 433   return module_filespec;
 434 }
 435
 436 #endif
 437
 438 #if !defined(__linux__)
 439 bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
 440   return false;
 441 }
 442 #endif
 443
 444 struct ShellInfo {
 445   ShellInfo()
 446       : process_reaped(false), pid(LLDB_INVALID_PROCESS_ID), signo(-1),
 447         status(-1) {}
 448
 449   lldb_private::Predicate<bool> process_reaped;
 450   lldb::pid_t pid;
 451   int signo;
 452   int status;
 453 };
 454
 455 static bool
 456 MonitorShellCommand(std::shared_ptr<ShellInfo> shell_info, lldb::pid_t pid,
 457                     bool exited, // True if the process did exit
 458                     int signo,   // Zero for no signal
 459                     int status)  // Exit value of process if signal is zero
 460 {
 461   shell_info->pid = pid;
 462   shell_info->signo = signo;
 463   shell_info->status = status;
 464   // Let the thread running Host::RunShellCommand() know that the process
 465   // exited and that ShellInfo has been filled in by broadcasting to it
 466   shell_info->process_reaped.SetValue(true, eBroadcastAlways);
 467   return true;
 468 }
 469
 470 Status Host::RunShellCommand(const char *command, const FileSpec &working_dir,
 471                              int *status_ptr, int *signo_ptr,
 472                              std::string *command_output_ptr,
 473                              uint32_t timeout_sec, bool run_in_default_shell) {
 474   return RunShellCommand(Args(command), working_dir, status_ptr, signo_ptr,
 475                          command_output_ptr, timeout_sec, run_in_default_shell);
 476 }
 477
 478 Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
 479                              int *status_ptr, int *signo_ptr,
 480                              std::string *command_output_ptr,
 481                              uint32_t timeout_sec, bool run_in_default_shell) {
 482   Status error;
 483   ProcessLaunchInfo launch_info;
 484   launch_info.SetArchitecture(HostInfo::GetArchitecture());
 485   if (run_in_default_shell) {
 486     // Run the command in a shell
 487     launch_info.SetShell(HostInfo::GetDefaultShell());
 488     launch_info.GetArguments().AppendArguments(args);
 489     const bool localhost = true;
 490     const bool will_debug = false;
 491     const bool first_arg_is_full_shell_command = false;
 492     launch_info.ConvertArgumentsForLaunchingInShell(
 493         error, localhost, will_debug, first_arg_is_full_shell_command, 0);
 494   } else {
 495     // No shell, just run it
 496     const bool first_arg_is_executable = true;
 497     launch_info.SetArguments(args, first_arg_is_executable);
 498   }
 499
 500   if (working_dir)
 501     launch_info.SetWorkingDirectory(working_dir);
 502   llvm::SmallString<PATH_MAX> output_file_path;
 503
 504   if (command_output_ptr) {
 505     // Create a temporary file to get the stdout/stderr and redirect the
 506     // output of the command into this file. We will later read this file
 507     // if all goes well and fill the data into "command_output_ptr"
 508     FileSpec tmpdir_file_spec;
 509     if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) {
 510       tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
 511       llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
 512                                       output_file_path);
 513     } else {
 514       llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "",
 515                                          output_file_path);
 516     }
 517   }
 518
 519   FileSpec output_file_spec{output_file_path.c_str(), false};
 520
 521   launch_info.AppendSuppressFileAction(STDIN_FILENO, true, false);
 522   if (output_file_spec) {
 523     launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_spec, false,
 524                                      true);
 525     launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO);
 526   } else {
 527     launch_info.AppendSuppressFileAction(STDOUT_FILENO, false, true);
 528     launch_info.AppendSuppressFileAction(STDERR_FILENO, false, true);
 529   }
 530
 531   std::shared_ptr<ShellInfo> shell_info_sp(new ShellInfo());
 532   const bool monitor_signals = false;
 533   launch_info.SetMonitorProcessCallback(
 534       std::bind(MonitorShellCommand, shell_info_sp, std::placeholders::_1,
 535                 std::placeholders::_2, std::placeholders::_3,
 536                 std::placeholders::_4),
 537       monitor_signals);
 538
 539   error = LaunchProcess(launch_info);
 540   const lldb::pid_t pid = launch_info.GetProcessID();
 541
 542   if (error.Success() && pid == LLDB_INVALID_PROCESS_ID)
 543     error.SetErrorString("failed to get process ID");
 544
 545   if (error.Success()) {
 546     bool timed_out = false;
 547     shell_info_sp->process_reaped.WaitForValueEqualTo(
 548         true, std::chrono::seconds(timeout_sec), &timed_out);
 549     if (timed_out) {
 550       error.SetErrorString("timed out waiting for shell command to complete");
 551
 552       // Kill the process since it didn't complete within the timeout specified
 553       Kill(pid, SIGKILL);
 554       // Wait for the monitor callback to get the message
 555       timed_out = false;
 556       shell_info_sp->process_reaped.WaitForValueEqualTo(
 557           true, std::chrono::seconds(1), &timed_out);
 558     } else {
 559       if (status_ptr)
 560         *status_ptr = shell_info_sp->status;
 561
 562       if (signo_ptr)
 563         *signo_ptr = shell_info_sp->signo;
 564
 565       if (command_output_ptr) {
 566         command_output_ptr->clear();
 567         uint64_t file_size = output_file_spec.GetByteSize();
 568         if (file_size > 0) {
 569           if (file_size > command_output_ptr->max_size()) {
 570             error.SetErrorStringWithFormat(
 571                 "shell command output is too large to fit into a std::string");
 572           } else {
 573             auto Buffer =
 574                 DataBufferLLVM::CreateFromPath(output_file_spec.GetPath());
 575             if (error.Success())
 576               command_output_ptr->assign(Buffer->GetChars(),
 577                                          Buffer->GetByteSize());
 578           }
 579         }
 580       }
 581     }
 582   }
 583
 584   llvm::sys::fs::remove(output_file_spec.GetPath());
 585   return error;
 586 }
 587
 588 // The functions below implement process launching for non-Apple-based platforms
 589 #if !defined(__APPLE__)
 590 Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
 591   std::unique_ptr<ProcessLauncher> delegate_launcher;
 592 #if defined(_WIN32)
 593   delegate_launcher.reset(new ProcessLauncherWindows());
 594 #else
 595   delegate_launcher.reset(new ProcessLauncherPosixFork());
 596 #endif
 597   MonitoringProcessLauncher launcher(std::move(delegate_launcher));
 598
 599   Status error;
 600   HostProcess process = launcher.LaunchProcess(launch_info, error);
 601
 602   // TODO(zturner): It would be better if the entire HostProcess were returned
 603   // instead of writing
 604   // it into this structure.
 605   launch_info.SetProcessID(process.GetProcessId());
 606
 607   return error;
 608 }
 609 #endif // !defined(__APPLE__)
 610
 611 #ifndef _WIN32
 612 void Host::Kill(lldb::pid_t pid, int signo) { ::kill(pid, signo); }
 613
 614 #endif
 615
 616 #if !defined(__APPLE__)
 617 bool Host::OpenFileInExternalEditor(const FileSpec &file_spec,
 618                                     uint32_t line_no) {
 619   return false;
 620 }
 621
 622 #endif
 623
 624 const UnixSignalsSP &Host::GetUnixSignals() {
 625   static const auto s_unix_signals_sp =
 626       UnixSignals::Create(HostInfo::GetArchitecture());
 627   return s_unix_signals_sp;
 628 }
 629
 630 std::unique_ptr<Connection> Host::CreateDefaultConnection(llvm::StringRef url) {
 631 #if defined(_WIN32)
 632   if (url.startswith("file://"))
 633     return std::unique_ptr<Connection>(new ConnectionGenericFile());
 634 #endif
 635   return std::unique_ptr<Connection>(new ConnectionFileDescriptor());
 636 }
 637
 638 #if defined(LLVM_ON_UNIX)
 639 WaitStatus WaitStatus::Decode(int wstatus) {
 640   if (WIFEXITED(wstatus))
 641     return {Exit, uint8_t(WEXITSTATUS(wstatus))};
 642   else if (WIFSIGNALED(wstatus))
 643     return {Signal, uint8_t(WTERMSIG(wstatus))};
 644   else if (WIFSTOPPED(wstatus))
 645     return {Stop, uint8_t(WSTOPSIG(wstatus))};
 646   llvm_unreachable("Unknown wait status");
 647 }
 648 #endif
 649
 650 void llvm::format_provider<WaitStatus>::format(const WaitStatus &WS,
 651                                                raw_ostream &OS,
 652                                                StringRef Options) {
 653   if (Options == "g") {
 654     char type;
 655     switch (WS.type) {
 656     case WaitStatus::Exit:
 657       type = 'W';
 658       break;
 659     case WaitStatus::Signal:
 660       type = 'X';
 661       break;
 662     case WaitStatus::Stop:
 663       type = 'S';
 664       break;
 665     }
 666     OS << formatv("{0}{1:x-2}", type, WS.status);
 667     return;
 668   }
 669
 670   assert(Options.empty());
 671   const char *desc;
 672   switch(WS.type) {
 673   case WaitStatus::Exit:
 674     desc = "Exited with status";
 675     break;
 676   case WaitStatus::Signal:
 677     desc = "Killed by signal";
 678     break;
 679   case WaitStatus::Stop:
 680     desc = "Stopped by signal";
 681     break;
 682   }
 683   OS << desc << " " << int(WS.status);
 684 }