[Support][AIX] Implement wait4 wrapper to fix build

[hubert.reinterpretcast]

Summary

While wait4 is not documented for AIX, it is available; however, even on systems where it is available, the system headers do not always provide a declaration of the function.

This patch firstly provides a declaration of wait4 for AIX. Secondly, it provides a wrapper for wait4 to work around issues that occur when using it directly with WNOHANG.

[hubert.reinterpretcast]

llvm/lib/Support/Unix/Program.inc

332

Is this meant to protect against wait4 as a function-like macro or also as an object-like macro? If the former, an alternate approach (see comment below) would work.

333

I asked around and the kwaitpid interface may be subject to change.

I was told that wait4 is actually available (just not listed in the documentation), and I was able to find the symbol in the system libc. Declaring the signature below with extern "C" should be enough.

If you prefer, I will put that fix in. Please let me know; thanks.

335

To avoid interpretation of wait4 as a function-like macro, it can be placed in parentheses: (wait4).

[sepavloff]

Could you please select 'Commandeer Revision' in the 'Add Action' field? You will be able to rule this patch.

llvm/lib/Support/Unix/Program.inc

332

Yes, it is protection against definition of wait4 as a macro. Such conflicts may give weird diagnostics.

333

Yes, please. I don't have access to AIX and cannot check patch.

335

Interesting solution, thank you!

[hubert.reinterpretcast]

llvm/lib/Support/Unix/Program.inc

333

Got it; working on it.

[hubert.reinterpretcast]

Add declaration of wait4 to fix AIX build

[daltenty]

LGTM apart from minor nit

llvm/lib/Support/Unix/Program.inc

332

nit: should this be #if defined(_AIX) && !defined(_ALL_SOURCE), we'd actually get this definition if we weren't in a POSIX compliant mode

[hubert.reinterpretcast]

llvm/lib/Support/Unix/Program.inc

374

Got a build, but it hangs. Will need to check this loop.

[ RUN      ] ProgramEnvTest.TestExecuteNoWait
Note: Google Test filter = ProgramEnvTest.TestExecuteNoWait
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from ProgramEnvTest
[ RUN      ] ProgramEnvTest.TestExecuteNoWait
Note: Google Test filter = ProgramEnvTest.TestExecuteNoWait
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from ProgramEnvTest
[ RUN      ] ProgramEnvTest.TestExecuteNoWait

[hubert.reinterpretcast]

llvm/lib/Support/Unix/Program.inc

374

AIX wait4 does not seem to work with WNOHANG. Attempting workaround...

[hubert.reinterpretcast]

• Implement wait4 wrapper for WNOHANG

[daltenty]

Confirming wrapper LGTM

llvm/lib/Support/Unix/Program.inc

 #include <crt_externs.h> // _NSGetEnviron
 #endif
 #endif
 
 namespace llvm {
 
 using namespace sys;
 
 ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {}
 
 ErrorOr<std::string> sys::findProgramByName(StringRef Name,
                                             ArrayRef<StringRef> Paths) {
   assert(!Name.empty() && "Must have a name!");
   // Use the given path verbatim if it contains any slashes; this matches
   // the behavior of sh(1) and friends.
   if (Name.find('/') != StringRef::npos) return std::string(Name);
 
   SmallVector<StringRef, 16> EnvironmentPaths;
   if (Paths.empty())
#ifdef RLIMIT_RSS
   setrlimit (RLIMIT_RSS, &r);
 #endif
 #endif
 }
 
 }
 
 static std::vector<const char *>
 toNullTerminatedCStringArray(ArrayRef<StringRef> Strings, StringSaver &Saver) {
   std::vector<const char *> Result;
   for (StringRef S : Strings)
     Result.push_back(Saver.save(S).data());
   Result.push_back(nullptr);
   return Result;
 }
 
 static bool Execute(ProcessInfo &PI, StringRef Program,
                     ArrayRef<StringRef> Args, Optional<ArrayRef<StringRef>> Env,
                     ArrayRef<Optional<StringRef>> Redirects,
                     unsigned MemoryLimit, std::string *ErrMsg) {
   if (!llvm::sys::fs::exists(Program)) {
     if (ErrMsg)
       *ErrMsg = std::string("Executable \"") + Program.str() +
                 std::string("\" doesn't exist!");
     return false;
   }
 
   BumpPtrAllocator Allocator;
   StringSaver Saver(Allocator);
   std::vector<const char *> ArgVector, EnvVector;
   const char **Argv = nullptr;
   const char **Envp = nullptr;
   ArgVector = toNullTerminatedCStringArray(Args, Saver);
   Argv = ArgVector.data();
   if (Env) {
     EnvVector = toNullTerminatedCStringArray(*Env, Saver);
     Envp = EnvVector.data();
if (!Redirects.empty()) {
           RedirectsStr[I] = &RedirectsStorage[I];
         }
       }
 
       FileActions = &FileActionsStore;
       posix_spawn_file_actions_init(FileActions);
 
       // Redirect stdin/stdout.
       if (RedirectIO_PS(RedirectsStr[0], 0, ErrMsg, FileActions) ||
           RedirectIO_PS(RedirectsStr[1], 1, ErrMsg, FileActions))
         return false;
       if (!Redirects[1] || !Redirects[2] || *Redirects[1] != *Redirects[2]) {
         // Just redirect stderr
         if (RedirectIO_PS(RedirectsStr[2], 2, ErrMsg, FileActions))
           return false;
       } else {
         // If stdout and stderr should go to the same place, redirect stderr
         // to the FD already open for stdout.
         if (int Err = posix_spawn_file_actions_adddup2(FileActions, 1, 2))
           return !MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout", Err);
       }
     }
#endif
   }
 
   PI.Pid = child;
   PI.Process = child;
 
   return true;
 }
 
+#if defined(_AIX) && !defined(wait4)
+extern pid_t kwaitpid(int *stat_loc, pid_t pid, int options,
+                      struct rusage *ru_loc, siginfo_t *infop);
+static pid_t wait4(pid_t pid, int *status, int options,
+                   struct rusage *usage) {
+  return kwaitpid(status, pid, options, usage, NULL);
+}
+#endif
+
 namespace llvm {
 
 ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
                       bool WaitUntilTerminates, std::string *ErrMsg,
                       Optional<ProcessStatistics> *ProcStat) {
   struct sigaction Act, Old;
   assert(PI.Pid && "invalid pid to wait on, process not started?");
 
ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
   int status;
   ProcessInfo WaitResult;
   rusage Info;
   if (ProcStat)
     ProcStat->reset();
 
   do {
     WaitResult.Pid = wait4(ChildPid, &status, WaitPidOptions, &Info);
   } while (WaitUntilTerminates && WaitResult.Pid == -1 && errno == EINTR);
 
   if (WaitResult.Pid != PI.Pid) {
     if (WaitResult.Pid == 0) {
       // Non-blocking wait.
       return WaitResult;
     } else {
       if (SecondsToWait && errno == EINTR) {
         // Kill the child.