[Support] Avoid wait4 on Fuchsia

[phosek]

Summary

Fuchsia doesn't provide wait4.

[mcgrathr]

What is implementing waitpid there? I'm not aware of any Fuchsia implementation of that API. The function in libc is an ENOSYS stub. If there were an emulation implementation of waitpid, there could as well be one for wait4 since some of the information analogous to struct rusage is accessible by other means on Fuchsia. But since there isn't AFAIK any waitpid et al that is actually useful on Fuchsia today, I'm a bit confused by this change. It seems like perhaps it's just getting something to compile and link that doesn't actually work. IMHO unless and until we provide a more full posix_spawn+wait* emulation library for Fuchsia--and perhaps even if we had one--the LLVM support should probably use the more direct Fuchsia mechanisms instead. For spawning subprocesses, that means fdio_spawn and then the direct Zircon syscall APIs to wait for process termination.

[phosek]

In D155793#4519503, @mcgrathr wrote:

What is implementing waitpid there? I'm not aware of any Fuchsia implementation of that API. The function in libc is an ENOSYS stub. If there were an emulation implementation of waitpid, there could as well be one for wait4 since some of the information analogous to struct rusage is accessible by other means on Fuchsia. But since there isn't AFAIK any waitpid et al that is actually useful on Fuchsia today, I'm a bit confused by this change. It seems like perhaps it's just getting something to compile and link that doesn't actually work. IMHO unless and until we provide a more full posix_spawn+wait* emulation library for Fuchsia--and perhaps even if we had one--the LLVM support should probably use the more direct Fuchsia mechanisms instead. For spawning subprocesses, that means fdio_spawn and then the direct Zircon syscall APIs to wait for process termination.

I'm aware that this implementation is not usable, right now the goal is just to make it compile to enable uses of other parts of LLVM that don't need this functionality (for example the DWARF parsing). I intend to replace all of this with native Fuchsia implementation in subsequent changes. For now I simplified this patch to avoid wait4 and waitpid altogether.

[mcgrathr]

Fuchsia also doesn't actually provide wait or waitpid, so some more comments to that effect at least in the log would be useful. It also doesn't have signals, so the calls earlier in the function won't actually do anything.
It probably makes more sense to just define llvm::sys::Wait so that it always fails without any real implementation contents under #ifdef __Fuchsia__.

llvm/lib/Support/Unix/Program.inc

465

Probably makes sense to set ProcStat->reset(); rather than not touching the output when we have no data.

llvm/lib/Support/Unix/Program.inc

#endif
   PI.Process = child;
 
   return true;
 }
 
 namespace llvm {
 namespace sys {
 
-#ifndef _AIX
-using ::wait4;
-#else
+#if defined(_AIX)
 static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage);
+#elif !defined(__Fuchsia__)
+using ::wait4;
 #endif
 
 } // namespace sys
 } // namespace llvm
 
 #ifdef _AIX
 #ifndef _ALL_SOURCE
 extern "C" pid_t(wait4)(pid_t pid, int *status, int options,
if (!SecondsToWait) {
     sigaction(SIGALRM, &Act, &Old);
     // FIXME The alarm signal may be delivered to another thread.
     alarm(*SecondsToWait);
   }
 
   // Parent process: Wait for the child process to terminate.
   int status = 0;
   ProcessInfo WaitResult;
+#ifndef __Fuchsia__
   rusage Info;
   if (ProcStat)
     ProcStat->reset();
 
   do {
     WaitResult.Pid = sys::wait4(ChildPid, &status, WaitPidOptions, &Info);
   } while (WaitUntilTerminates && WaitResult.Pid == -1 && errno == EINTR);
+#endif
 
   if (WaitResult.Pid != PI.Pid) {
     if (WaitResult.Pid == 0) {
       // Non-blocking wait.
       return WaitResult;
     } else {
       if (SecondsToWait && errno == EINTR && !Polling) {
         // Kill the child.
#endif
   }
 
   // We exited normally without timeout, so turn off the timer.
   if (SecondsToWait && !WaitUntilTerminates) {
     alarm(0);
     sigaction(SIGALRM, &Old, nullptr);
   }
 
+#ifndef __Fuchsia__
   if (ProcStat) {
     std::chrono::microseconds UserT = toDuration(Info.ru_utime);
     std::chrono::microseconds KernelT = toDuration(Info.ru_stime);
     uint64_t PeakMemory = 0;
 #ifndef __HAIKU__
     PeakMemory = static_cast<uint64_t>(Info.ru_maxrss);
 #endif
     *ProcStat = ProcessStatistics{UserT + KernelT, UserT, PeakMemory};
   }
+#endif
 
   // Return the proper exit status. Detect error conditions
   // so we can return -1 for them and set ErrMsg informatively.
   int result = 0;
   if (WIFEXITED(status)) {
     result = WEXITSTATUS(status);
     WaitResult.ReturnCode = result;