Adding upstream version 1:0.1.9998svn3589+dfsg.upstream/1%0.1.9998svn3589+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

22 files changed, 7703 insertions, 0 deletions

diff --git a/src/kmk/w32/Makefile.am b/src/kmk/w32/Makefile.am
new file mode 100644
index 0000000..5527f77
--- /dev/null
+++ b/src/kmk/w32/Makefile.am
@@ -0,0 +1,26 @@
+# Makefile.am to create libw32.a for mingw32 host.
+# Copyright (C) 1997-2016 Free Software Foundation, Inc.
+# This file is part of GNU Make.
+#
+# GNU Make is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option) any later
+# version.
+#
+# GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+AUTOMAKE_OPTIONS = subdir-objects
+
+noinst_LIBRARIES = libw32.a
+
+libw32_a_SOURCES =  subproc/misc.c subproc/sub_proc.c subproc/w32err.c \
+		    compat/posixfcn.c pathstuff.c w32os.c
+
+libw32_a_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/subproc -I$(top_srcdir) \
+		    -I$(top_srcdir)/glob
diff --git a/src/kmk/w32/Makefile.kup b/src/kmk/w32/Makefile.kup
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/kmk/w32/Makefile.kup
diff --git a/src/kmk/w32/compat/Makefile.kup b/src/kmk/w32/compat/Makefile.kup
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/kmk/w32/compat/Makefile.kup
diff --git a/src/kmk/w32/compat/dirent.c b/src/kmk/w32/compat/dirent.c
new file mode 100644
index 0000000..9f992ec
--- /dev/null
+++ b/src/kmk/w32/compat/dirent.c
@@ -0,0 +1,212 @@
+/* Directory entry code for Window platforms.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+
+#include <config.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#ifdef KMK_PRF
+# include <stdio.h>
+#endif
+#include "dirent.h"
+
+
+DIR*
+opendir(const char* pDirName)
+{
+        struct stat sb;
+        DIR*    pDir;
+        char*   pEndDirName;
+        int     nBufferLen;
+
+        /* sanity checks */
+        if (!pDirName) {
+                errno = EINVAL;
+                return NULL;
+        }
+        if (stat(pDirName, &sb) != 0) {
+                errno = ENOENT;
+                return NULL;
+        }
+        if ((sb.st_mode & S_IFMT) != S_IFDIR) {
+                errno = ENOTDIR;
+                return NULL;
+        }
+
+        /* allocate a DIR structure to return */
+        pDir = (DIR *) malloc(sizeof (DIR));
+
+        if (!pDir)
+                return NULL;
+
+        /* input directory name length */
+        nBufferLen = strlen(pDirName);
+
+        /* copy input directory name to DIR buffer */
+        strcpy(pDir->dir_pDirectoryName, pDirName);
+
+        /* point to end of the copied directory name */
+        pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1];
+
+        /* if directory name did not end in '/' or '\', add '/' */
+        if ((*pEndDirName != '/') && (*pEndDirName != '\\')) {
+                pEndDirName++;
+                *pEndDirName = '/';
+        }
+
+        /* now append the wildcard character to the buffer */
+        pEndDirName++;
+        *pEndDirName = '*';
+        pEndDirName++;
+        *pEndDirName = '\0';
+
+        /* other values defaulted */
+        pDir->dir_nNumFiles = 0;
+        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
+        pDir->dir_ulCookie = __DIRENT_COOKIE;
+
+#ifdef KMK_PRF
+        fprintf(stderr, "opendir(%s) -> %p\n", pDirName, pDir);
+#endif
+        return pDir;
+}
+
+void
+closedir(DIR *pDir)
+{
+        /* got a valid pointer? */
+        if (!pDir) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* close the WINDOWS32 directory handle */
+        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
+                FindClose(pDir->dir_hDirHandle);
+
+        free(pDir);
+
+        return;
+}
+
+struct dirent *
+readdir(DIR* pDir)
+{
+        WIN32_FIND_DATA wfdFindData;
+
+        if (!pDir) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        if (pDir->dir_nNumFiles == 0) {
+                pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData);
+                if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE)
+                        return NULL;
+        } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData))
+                        return NULL;
+
+        /* bump count for next call to readdir() or telldir() */
+        pDir->dir_nNumFiles++;
+
+        /* fill in struct dirent values */
+        pDir->dir_sdReturn.d_ino = (ino_t)-1;
+        strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName);
+
+        return &pDir->dir_sdReturn;
+}
+
+void
+rewinddir(DIR* pDir)
+{
+        if (!pDir) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* close the WINDOWS32 directory handle */
+        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
+                if (!FindClose(pDir->dir_hDirHandle))
+                        errno = EBADF;
+
+        /* reset members which control readdir() */
+        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
+        pDir->dir_nNumFiles = 0;
+
+        return;
+}
+
+int
+telldir(DIR* pDir)
+{
+        if (!pDir) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        /* return number of times readdir() called */
+        return pDir->dir_nNumFiles;
+}
+
+void
+seekdir(DIR* pDir, long nPosition)
+{
+        if (!pDir)
+                return;
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE)
+                return;
+
+        /* go back to beginning of directory */
+        rewinddir(pDir);
+
+        /* loop until we have found position we care about */
+        for (--nPosition; nPosition && readdir(pDir); nPosition--);
+
+        /* flag invalid nPosition value */
+        if (nPosition)
+                errno = EINVAL;
+
+        return;
+}
diff --git a/src/kmk/w32/compat/posixfcn.c b/src/kmk/w32/compat/posixfcn.c
new file mode 100644
index 0000000..a537ca2
--- /dev/null
+++ b/src/kmk/w32/compat/posixfcn.c
@@ -0,0 +1,516 @@
+/* Replacements for Posix functions and Posix functionality for MS-Windows.
+
+Copyright (C) 2013-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <string.h>
+#include <io.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <windows.h>
+
+#include "dlfcn.h"
+
+#include "makeint.h"
+#include "job.h"
+
+#ifndef NO_OUTPUT_SYNC
+/* Support for OUTPUT_SYNC and related functionality.  */
+
+/* Emulation of fcntl that supports only F_GETFD and F_SETLKW.  */
+int
+fcntl (intptr_t fd, int cmd, ...)
+{
+  va_list ap;
+
+  va_start (ap, cmd);
+
+  switch (cmd)
+    {
+      case F_GETFD:
+        va_end (ap);
+        /* Could have used GetHandleInformation, but that isn't
+           supported on Windows 9X.  */
+        if (_get_osfhandle (fd) == -1)
+          return -1;
+        return 0;
+      case F_SETLKW:
+        {
+          void *buf = va_arg (ap, void *);
+          struct flock *fl = (struct flock *)buf;
+          HANDLE hmutex = (HANDLE)fd;
+          static struct flock last_fl;
+          short last_type = last_fl.l_type;
+
+          va_end (ap);
+
+          if (hmutex == INVALID_HANDLE_VALUE || !hmutex)
+            return -1;
+
+          last_fl = *fl;
+
+          switch (fl->l_type)
+            {
+
+              case F_WRLCK:
+                {
+                  DWORD result;
+
+                  if (last_type == F_WRLCK)
+                    {
+                      /* Don't call WaitForSingleObject if we already
+                         own the mutex, because doing so will require
+                         us to call ReleaseMutex an equal number of
+                         times, before the mutex is actually
+                         released.  */
+                      return 0;
+                    }
+
+                  result = WaitForSingleObject (hmutex, INFINITE);
+                  switch (result)
+                    {
+                      case WAIT_OBJECT_0:
+                        /* We don't care if the mutex owner crashed or
+                           exited.  */
+                      case WAIT_ABANDONED:
+                        return 0;
+                      case WAIT_FAILED:
+                      case WAIT_TIMEOUT: /* cannot happen, really */
+                        {
+                          DWORD err = GetLastError ();
+
+                          /* Invalidate the last command.  */
+                          memset (&last_fl, 0, sizeof (last_fl));
+
+                          switch (err)
+                            {
+                              case ERROR_INVALID_HANDLE:
+                              case ERROR_INVALID_FUNCTION:
+                                errno = EINVAL;
+                                return -1;
+                              default:
+                                errno = EDEADLOCK;
+                                return -1;
+                            }
+                        }
+                    }
+                }
+              case F_UNLCK:
+                {
+                  /* FIXME: Perhaps we should call ReleaseMutex
+                     repatedly until it errors out, to make sure the
+                     mutext is released even if we somehow managed to
+                     to take ownership multiple times?  */
+                  BOOL status = ReleaseMutex (hmutex);
+
+                  if (status)
+                    return 0;
+                  else
+                    {
+                      DWORD err = GetLastError ();
+
+                      if (err == ERROR_NOT_OWNER)
+                        errno = EPERM;
+                      else
+                        {
+                          memset (&last_fl, 0, sizeof (last_fl));
+                          errno = EINVAL;
+                        }
+                      return -1;
+                    }
+                }
+              default:
+                errno = ENOSYS;
+                return -1;
+            }
+        }
+      default:
+        errno = ENOSYS;
+        va_end (ap);
+        return -1;
+    }
+}
+
+static intptr_t mutex_handle = -1;
+
+/* Record in a static variable the mutex handle we were requested to
+   use.  That nameless mutex was created by the top-level Make, and
+   its handle was passed to us via inheritance.  The value of that
+   handle is passed via the command-line arguments, so that we know
+   which handle to use.  */
+void
+record_sync_mutex (const char *str)
+{
+#ifdef CONFIG_NEW_WIN_CHILDREN
+  HANDLE hmtx = OpenMutexA(SYNCHRONIZE, FALSE /*fInheritable*/, str);
+  if (hmtx)
+    mutex_handle = (intptr_t)hmtx;
+  else
+    {
+      mutex_handle = -1;
+      errno = ENOENT;
+    }
+#else
+  char *endp;
+  intptr_t hmutex = strtol (str, &endp, 16);
+
+  if (*endp == '\0')
+    mutex_handle = hmutex;
+  else
+    {
+      mutex_handle = -1;
+      errno = EINVAL;
+    }
+#endif
+}
+
+/* Create a new mutex or reuse one created by our parent.  */
+intptr_t
+#ifdef CONFIG_NEW_WIN_CHILDREN
+create_mutex (char *mtxname, size_t size)
+#else
+create_mutex (void)
+#endif
+{
+#ifndef CONFIG_NEW_WIN_CHILDREN
+  SECURITY_ATTRIBUTES secattr;
+#endif
+  intptr_t hmutex = -1;
+
+  /* If we have a mutex handle passed from the parent Make, just use
+     that.  */
+  if (mutex_handle > 0)
+    {
+#ifdef CONFIG_NEW_WIN_CHILDREN
+      mtxname[0] = '\0';
+#endif
+      return mutex_handle;
+    }
+
+#ifdef CONFIG_NEW_WIN_CHILDREN
+  /* We're the top-level Make. Child Make processes will open our mutex, since
+     children does not inherit any handles other than the three standard ones. */
+  snprintf(mtxname, size, "Make-output-%u-%u-%u", GetCurrentProcessId(),
+           GetCurrentThreadId(), GetTickCount());
+  hmutex = (intptr_t)CreateMutexA (NULL, FALSE /*Locked*/, mtxname);
+#else
+  /* We are the top-level Make, and we want the handle to be inherited
+     by our child processes.  */
+  secattr.nLength = sizeof (secattr);
+  secattr.lpSecurityDescriptor = NULL; /* use default security descriptor */
+  secattr.bInheritHandle = TRUE;
+
+  hmutex = (intptr_t)CreateMutex (&secattr, FALSE, NULL);
+#endif
+  if (!hmutex)
+    {
+      DWORD err = GetLastError ();
+
+      fprintf (stderr, "CreateMutex: error %lu\n", err);
+      errno = ENOLCK;
+      hmutex = -1;
+    }
+
+  mutex_handle = hmutex;
+  return hmutex;
+}
+
+/* Return non-zero if F1 and F2 are 2 streams representing the same
+   file or pipe or device.  */
+int
+same_stream (FILE *f1, FILE *f2)
+{
+  HANDLE fh1 = (HANDLE)_get_osfhandle (fileno (f1));
+  HANDLE fh2 = (HANDLE)_get_osfhandle (fileno (f2));
+
+  /* Invalid file descriptors get treated as different streams.  */
+  if (fh1 && fh1 != INVALID_HANDLE_VALUE
+      && fh2 && fh2 != INVALID_HANDLE_VALUE)
+    {
+      if (fh1 == fh2)
+        return 1;
+      else
+        {
+          DWORD ftyp1 = GetFileType (fh1), ftyp2 = GetFileType (fh2);
+
+          if (ftyp1 != ftyp2
+              || ftyp1 == FILE_TYPE_UNKNOWN || ftyp2 == FILE_TYPE_UNKNOWN)
+            return 0;
+          else if (ftyp1 == FILE_TYPE_CHAR)
+            {
+              /* For character devices, check if they both refer to a
+                 console.  This loses if both handles refer to the
+                 null device (FIXME!), but in that case we don't care
+                 in the context of Make.  */
+              DWORD conmode1, conmode2;
+
+              /* Each process on Windows can have at most 1 console,
+                 so if both handles are for the console device, they
+                 are the same.  We also compare the console mode to
+                 distinguish between stdin and stdout/stderr.  */
+              if (GetConsoleMode (fh1, &conmode1)
+                  && GetConsoleMode (fh2, &conmode2)
+                  && conmode1 == conmode2)
+                return 1;
+            }
+          else
+            {
+              /* For disk files and pipes, compare their unique
+                 attributes.  */
+              BY_HANDLE_FILE_INFORMATION bhfi1, bhfi2;
+
+              /* Pipes get zero in the volume serial number, but do
+                 appear to have meaningful information in file index
+                 attributes.  We test file attributes as well, for a
+                 good measure.  */
+              if (GetFileInformationByHandle (fh1, &bhfi1)
+                  && GetFileInformationByHandle (fh2, &bhfi2))
+                return (bhfi1.dwVolumeSerialNumber == bhfi2.dwVolumeSerialNumber
+                        && bhfi1.nFileIndexLow == bhfi2.nFileIndexLow
+                        && bhfi1.nFileIndexHigh == bhfi2.nFileIndexHigh
+                        && bhfi1.dwFileAttributes == bhfi2.dwFileAttributes);
+            }
+        }
+    }
+  return 0;
+}
+
+/* A replacement for tmpfile, since the MSVCRT implementation creates
+   the file in the root directory of the current drive, which might
+   not be writable by our user.  Most of the code borrowed from
+   create_batch_file, see job.c.  */
+FILE *
+tmpfile (void)
+{
+  char temp_path[MAXPATHLEN];
+  unsigned path_size = GetTempPath (sizeof temp_path, temp_path);
+  int path_is_dot = 0;
+  /* The following variable is static so we won't try to reuse a name
+     that was generated a little while ago, because that file might
+     not be on disk yet, since we use FILE_ATTRIBUTE_TEMPORARY below,
+     which tells the OS it doesn't need to flush the cache to disk.
+     If the file is not yet on disk, we might think the name is
+     available, while it really isn't.  This happens in parallel
+     builds, where Make doesn't wait for one job to finish before it
+     launches the next one.  */
+  static unsigned uniq = 0;
+  static int second_loop = 0;
+  const char base[] = "gmake_tmpf";
+  const unsigned sizemax = sizeof base - 1 + 4 + 10 + 10;
+  unsigned pid = GetCurrentProcessId ();
+
+  if (path_size == 0)
+    {
+      path_size = GetCurrentDirectory (sizeof temp_path, temp_path);
+      path_is_dot = 1;
+    }
+
+  ++uniq;
+  if (uniq >= 0x10000 && !second_loop)
+    {
+      /* If we already had 64K batch files in this
+         process, make a second loop through the numbers,
+         looking for free slots, i.e. files that were
+         deleted in the meantime.  */
+      second_loop = 1;
+      uniq = 1;
+    }
+  while (path_size > 0 &&
+         path_size + sizemax < sizeof temp_path &&
+         !(uniq >= 0x10000 && second_loop))
+    {
+      HANDLE h;
+
+      sprintf (temp_path + path_size,
+               "%s%s%u-%x.tmp",
+               temp_path[path_size - 1] == '\\' ? "" : "\\",
+               base, pid, uniq);
+      h = CreateFile (temp_path,  /* file name */
+                      GENERIC_READ | GENERIC_WRITE | DELETE, /* desired access */
+                      FILE_SHARE_READ | FILE_SHARE_WRITE,    /* share mode */
+                      NULL,                                  /* default security attributes */
+                      CREATE_NEW,                            /* creation disposition */
+                      FILE_ATTRIBUTE_NORMAL |                /* flags and attributes */
+                      FILE_ATTRIBUTE_TEMPORARY |
+                      FILE_FLAG_DELETE_ON_CLOSE,
+                      NULL);                                 /* no template file */
+
+      if (h == INVALID_HANDLE_VALUE)
+        {
+          const DWORD er = GetLastError ();
+
+          if (er == ERROR_FILE_EXISTS || er == ERROR_ALREADY_EXISTS)
+            {
+              ++uniq;
+              if (uniq == 0x10000 && !second_loop)
+                {
+                  second_loop = 1;
+                  uniq = 1;
+                }
+            }
+
+          /* The temporary path is not guaranteed to exist, or might
+             not be writable by user.  Use the current directory as
+             fallback.  */
+          else if (path_is_dot == 0)
+            {
+              path_size = GetCurrentDirectory (sizeof temp_path, temp_path);
+              path_is_dot = 1;
+            }
+
+          else
+            {
+              errno = EACCES;
+              break;
+            }
+        }
+      else
+        {
+          int fd = _open_osfhandle ((intptr_t)h, 0);
+
+          return _fdopen (fd, "w+b");
+        }
+    }
+
+  if (uniq >= 0x10000)
+    errno = EEXIST;
+  return NULL;
+}
+
+#endif  /* !NO_OUTPUT_SYNC */
+
+#if MAKE_LOAD
+
+/* Support for dynamic loading of objects.  */
+
+
+static DWORD last_err;
+
+void *
+dlopen (const char *file, int mode)
+{
+  char dllfn[MAX_PATH], *p;
+  HANDLE dllhandle;
+
+  if ((mode & ~(RTLD_LAZY | RTLD_NOW | RTLD_GLOBAL)) != 0)
+    {
+      errno = EINVAL;
+      last_err = ERROR_INVALID_PARAMETER;
+      return NULL;
+    }
+
+  if (!file)
+    dllhandle = GetModuleHandle (NULL);
+  else
+    {
+      /* MSDN says to be sure to use backslashes in the DLL file name.  */
+      strcpy (dllfn, file);
+      for (p = dllfn; *p; p++)
+        if (*p == '/')
+          *p = '\\';
+
+      dllhandle = LoadLibrary (dllfn);
+    }
+  if (!dllhandle)
+    last_err = GetLastError ();
+
+  return dllhandle;
+}
+
+char *
+dlerror (void)
+{
+  static char errbuf[1024];
+  DWORD ret;
+
+  if (!last_err)
+    return NULL;
+
+  ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
+                       | FORMAT_MESSAGE_IGNORE_INSERTS,
+                       NULL, last_err, 0, errbuf, sizeof (errbuf), NULL);
+  while (ret > 0 && (errbuf[ret - 1] == '\n' || errbuf[ret - 1] == '\r'))
+    --ret;
+
+  errbuf[ret] = '\0';
+  if (!ret)
+    sprintf (errbuf, "Error code %lu", last_err);
+
+  last_err = 0;
+  return errbuf;
+}
+
+void *
+dlsym (void *handle, const char *name)
+{
+  FARPROC addr = NULL;
+
+  if (!handle || handle == INVALID_HANDLE_VALUE)
+    {
+      last_err = ERROR_INVALID_PARAMETER;
+      return NULL;
+    }
+
+  addr = GetProcAddress (handle, name);
+  if (!addr)
+    last_err = GetLastError ();
+
+  return (void *)addr;
+}
+
+int
+dlclose (void *handle)
+{
+  if (!handle || handle == INVALID_HANDLE_VALUE)
+    return -1;
+  if (!FreeLibrary (handle))
+    return -1;
+
+  return 0;
+}
+
+
+#endif  /* MAKE_LOAD */
+
+
+/* MS runtime's isatty returns non-zero for any character device,
+   including the null device, which is not what we want.  */
+int
+isatty (int fd)
+{
+  HANDLE fh = (HANDLE) _get_osfhandle (fd);
+  DWORD con_mode;
+
+  if (fh == INVALID_HANDLE_VALUE)
+    {
+      errno = EBADF;
+      return 0;
+    }
+  if (GetConsoleMode (fh, &con_mode))
+    return 1;
+
+  errno = ENOTTY;
+  return 0;
+}
+
+char *
+ttyname (int fd)
+{
+  /* This "knows" that Make only asks about stdout and stderr.  A more
+     sophisticated implementation should test whether FD is open for
+     input or output.  We can do that by looking at the mode returned
+     by GetConsoleMode.  */
+  return "CONOUT$";
+}
diff --git a/src/kmk/w32/imagecache.c b/src/kmk/w32/imagecache.c
new file mode 100644
index 0000000..2b26dac
--- /dev/null
+++ b/src/kmk/w32/imagecache.c
@@ -0,0 +1,219 @@
+/* $Id: imagecache.c 3195 2018-03-27 18:09:23Z bird $ */
+/** @file
+ * kBuild specific executable image cache for Windows.
+ */
+
+/*
+ * Copyright (c) 2012 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ *
+ * This file is part of kBuild.
+ *
+ * kBuild is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * kBuild is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with kBuild.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+/* No GNU coding style here! */
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "makeint.h"
+
+#include <Windows.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct EXECCACHEENTRY
+{
+    /** The name hash value. */
+    unsigned                uHash;
+    /** The name length. */
+    unsigned                cwcName;
+    /** Pointer to the next name with the same hash. */
+    struct EXECCACHEENTRY  *pNext;
+    /** When it was last referenced. */
+    unsigned                uLastRef;
+    /** The module handle, LOAD_LIBRARY_AS_DATAFILE. */
+    HMODULE                 hmod1;
+    /** The module handle, DONT_RESOLVE_DLL_REFERENCES. */
+    HMODULE                 hmod2;
+    /** The executable path. */
+    wchar_t                 wszName[1];
+} EXECCACHEENTRY;
+typedef EXECCACHEENTRY *PEXECCACHEENTRY;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Critical section serializing all access. */
+static CRITICAL_SECTION g_CritSect;
+/** Set if initialized. */
+static int volatile     g_fInitialized = 0;
+/** The number of cached images. */
+static unsigned         g_cCached;
+/** Used noting when entries was last used.
+ * Increased on each kmk_cache_exec_image call.  */
+static unsigned         g_uNow;
+
+/** The size of the hash table. */
+#define EXECCACHE_HASHTAB_SIZE  128
+/** The hash table. */
+static PEXECCACHEENTRY  g_apHashTab[EXECCACHE_HASHTAB_SIZE];
+
+
+/** A sleepy approach to do-once. */
+static void kmk_cache_lazy_init(void)
+{
+    if (_InterlockedCompareExchange(&g_fInitialized, -1, 0) == 0)
+    {
+        InitializeCriticalSection(&g_CritSect);
+        _InterlockedExchange(&g_fInitialized, 1);
+    }
+    else
+        while (g_fInitialized != 1)
+            Sleep(1);
+}
+
+
+/* sdbm:
+   This algorithm was created for sdbm (a public-domain reimplementation of
+   ndbm) database library. it was found to do well in scrambling bits,
+   causing better distribution of the keys and fewer splits. it also happens
+   to be a good general hashing function with good distribution. the actual
+   function is hash(i) = hash(i - 1) * 65599 + str[i]; what is included below
+   is the faster version used in gawk. [there is even a faster, duff-device
+   version] the magic constant 65599 was picked out of thin air while
+   experimenting with different constants, and turns out to be a prime.
+   this is one of the algorithms used in berkeley db (see sleepycat) and
+   elsewhere. */
+
+static unsigned execcache_calc_hash(const wchar_t *pwsz, size_t *pcch)
+{
+    wchar_t const  * const pwszStart = pwsz;
+    unsigned               hash = 0;
+    int                    ch;
+
+    while ((ch = *pwsz++) != L'\0')
+        hash = ch + (hash << 6) + (hash << 16) - hash;
+
+    *pcch = (size_t)(pwsz - pwszStart - 1);
+    return hash;
+}
+
+/**
+ * Caches two memory mappings of the specified image so that it isn't flushed
+ * from the kernel's cache mananger.
+ *
+ * Not sure exactly how much this actually helps, but whatever...
+ *
+ * @param   pwszExec    The executable.
+ */
+extern void kmk_cache_exec_image_w(const wchar_t *pwszExec)
+{
+    /*
+     * Prepare name lookup and to lazy init.
+     */
+    size_t              cwcName;
+    const unsigned      uHash = execcache_calc_hash(pwszExec, &cwcName);
+    PEXECCACHEENTRY    *ppCur = &g_apHashTab[uHash % EXECCACHE_HASHTAB_SIZE];
+    PEXECCACHEENTRY     pCur;
+
+    if (g_fInitialized != 1)
+        kmk_cache_lazy_init();
+
+    /*
+     * Do the lookup.
+     */
+    EnterCriticalSection(&g_CritSect);
+    pCur = *ppCur;
+    while (pCur)
+    {
+        if (   pCur->uHash   == uHash
+            && pCur->cwcName == cwcName
+            && !memcmp(pCur->wszName, pwszExec, cwcName * sizeof(wchar_t)))
+        {
+            pCur->uLastRef = ++g_uNow;
+            LeaveCriticalSection(&g_CritSect);
+            return;
+        }
+        ppCur = &pCur->pNext;
+        pCur = pCur->pNext;
+    }
+    LeaveCriticalSection(&g_CritSect);
+
+    /*
+     * Not found, create a new entry.
+     */
+    pCur = xmalloc(sizeof(*pCur) + cwcName * sizeof(wchar_t));
+    pCur->uHash    = uHash;
+    pCur->cwcName  = (unsigned)cwcName;
+    pCur->pNext    = NULL;
+    pCur->uLastRef = ++g_uNow;
+    memcpy(pCur->wszName, pwszExec, (cwcName + 1) * sizeof(wchar_t));
+    pCur->hmod1 = LoadLibraryExW(pwszExec, NULL, LOAD_LIBRARY_AS_DATAFILE);
+    if (pCur->hmod1 != NULL)
+        pCur->hmod2 = LoadLibraryExW(pwszExec, NULL, DONT_RESOLVE_DLL_REFERENCES);
+    else
+        pCur->hmod2 = NULL;
+
+    /*
+     * Insert it.
+     * Take into account that we might've been racing other threads,
+     * fortunately we don't evict anything from the cache.
+     */
+    EnterCriticalSection(&g_CritSect);
+    if (*ppCur != NULL)
+    {
+        /* Find new end of chain and check for duplicate. */
+        PEXECCACHEENTRY pCur2 = *ppCur;
+        while (pCur2)
+        {
+            if (   pCur->uHash   == uHash
+                && pCur->cwcName == cwcName
+                && !memcmp(pCur->wszName, pwszExec, cwcName * sizeof(wchar_t)))
+                break;
+            ppCur = &pCur->pNext;
+            pCur = pCur->pNext;
+        }
+
+    }
+    if (*ppCur == NULL)
+    {
+        *ppCur = pCur;
+        g_cCached++;
+        LeaveCriticalSection(&g_CritSect);
+    }
+    else
+    {
+        LeaveCriticalSection(&g_CritSect);
+
+        if (pCur->hmod1 != NULL)
+            FreeLibrary(pCur->hmod1);
+        if (pCur->hmod2 != NULL)
+            FreeLibrary(pCur->hmod2);
+        free(pCur);
+    }
+}
+
+extern void kmk_cache_exec_image_a(const char *pszExec)
+{
+    wchar_t wszExec[260];
+    int cwc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszExec, strlen(pszExec) + 1, wszExec, 260);
+    if (cwc > 0)
+        kmk_cache_exec_image_w(wszExec);
+}
+
diff --git a/src/kmk/w32/include/dirent.h b/src/kmk/w32/include/dirent.h
new file mode 100644
index 0000000..c349e85
--- /dev/null
+++ b/src/kmk/w32/include/dirent.h
@@ -0,0 +1,66 @@
+/* Windows version of dirent.h
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef _DIRENT_H
+#define _DIRENT_H
+
+#ifdef KMK
+# include <windows.h>
+# include "nt/ntdir.h"
+
+#else /* !KMK */
+
+#ifdef __MINGW32__
+# include <windows.h>
+# include_next <dirent.h>
+#else
+
+#include <stdlib.h>
+#include <windows.h>
+#include <limits.h>
+#include <sys/types.h>
+
+#ifndef NAME_MAX
+#define NAME_MAX 255
+#endif
+
+#define __DIRENT_COOKIE 0xfefeabab
+
+
+struct dirent
+{
+  ino_t d_ino;                  /* unused - no equivalent on WINDOWS32 */
+  char d_name[NAME_MAX+1];
+};
+
+typedef struct dir_struct {
+        ULONG   dir_ulCookie;
+        HANDLE  dir_hDirHandle;
+        DWORD   dir_nNumFiles;
+        char    dir_pDirectoryName[NAME_MAX+1];
+        struct dirent dir_sdReturn;
+} DIR;
+
+DIR *opendir(const char *);
+struct dirent *readdir(DIR *);
+void rewinddir(DIR *);
+void closedir(DIR *);
+int telldir(DIR *);
+void seekdir(DIR *, long);
+
+#endif  /* !__MINGW32__ */
+#endif  /* !KMK */
+#endif
diff --git a/src/kmk/w32/include/dlfcn.h b/src/kmk/w32/include/dlfcn.h
new file mode 100644
index 0000000..5a2ae28
--- /dev/null
+++ b/src/kmk/w32/include/dlfcn.h
@@ -0,0 +1,29 @@
+/* dlfcn.h replacement for MS-Windows build.
+Copyright (C) 2013-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef DLFCN_H
+#define DLFCN_H
+
+#define RTLD_LAZY   1
+#define RTLD_NOW    2
+#define RTLD_GLOBAL 4
+
+extern void *dlopen (const char *, int);
+extern void *dlsym (void *, const char *);
+extern char *dlerror (void);
+extern int   dlclose (void *);
+
+#endif  /* DLFCN_H */
diff --git a/src/kmk/w32/include/pathstuff.h b/src/kmk/w32/include/pathstuff.h
new file mode 100644
index 0000000..3f839ec
--- /dev/null
+++ b/src/kmk/w32/include/pathstuff.h
@@ -0,0 +1,30 @@
+/* Definitions for Windows path manipulation.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef _PATHSTUFF_H
+#define _PATHSTUFF_H
+
+char *convert_Path_to_windows32(char *Path, char to_delim);
+char *convert_vpath_to_windows32(char *Path, char to_delim);
+#if 1
+char *unix_slashes(char *filename); /* bird */
+char *unix_slashes_resolved(const char *src, char *dst, unsigned len); /* bird */
+#else
+char *w32ify(const char *filename, int resolve);
+#endif
+char *getcwd_fs(char *buf, int len);
+
+#endif
diff --git a/src/kmk/w32/include/sub_proc.h b/src/kmk/w32/include/sub_proc.h
new file mode 100644
index 0000000..51e3830
--- /dev/null
+++ b/src/kmk/w32/include/sub_proc.h
@@ -0,0 +1,72 @@
+/* Definitions for Windows process invocation.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef SUB_PROC_H
+#define SUB_PROC_H
+#ifdef CONFIG_NEW_WIN_CHILDREN
+# error "Just checking..."
+#endif
+
+/*
+ * Component Name:
+ *
+ * $Date$
+ *
+ * $Source$
+ *
+ * $Id$
+ */
+
+#define EXTERN_DECL(entry, args) extern entry args
+#define VOID_DECL void
+
+EXTERN_DECL(HANDLE process_init, (VOID_DECL));
+EXTERN_DECL(HANDLE process_init_fd, (HANDLE stdinh, HANDLE stdouth,
+                                     HANDLE stderrh));
+EXTERN_DECL(long process_begin, (HANDLE proc, char **argv, char **envp,
+                                 char *exec_path, char *as_user));
+EXTERN_DECL(long process_pipe_io, (HANDLE proc, char *stdin_data,
+                                   int stdin_data_len));
+#ifndef KMK /* unused */
+EXTERN_DECL(long process_file_io, (HANDLE proc));
+#endif
+EXTERN_DECL(void process_cleanup, (HANDLE proc));
+EXTERN_DECL(HANDLE process_wait_for_any, (int block, DWORD* pdwWaitStatus));
+EXTERN_DECL(void process_register, (HANDLE proc));
+EXTERN_DECL(HANDLE process_easy, (char** argv, char** env,
+                                  int outfd, int errfd));
+EXTERN_DECL(BOOL process_kill, (HANDLE proc, int signal));
+EXTERN_DECL(int process_used_slots, (VOID_DECL));
+EXTERN_DECL(DWORD process_set_handles, (HANDLE *handles));
+
+#ifdef KMK
+EXTERN_DECL(int process_kmk_register_submit, (HANDLE hEvent, intptr_t clue, pid_t *pPid));
+EXTERN_DECL(int process_kmk_register_redirect, (HANDLE hProcess, pid_t *pPid));
+#endif
+
+/* support routines */
+EXTERN_DECL(long process_errno, (HANDLE proc));
+EXTERN_DECL(long process_last_err, (HANDLE proc));
+EXTERN_DECL(long process_exit_code, (HANDLE proc));
+EXTERN_DECL(long process_signal, (HANDLE proc));
+EXTERN_DECL(char * process_outbuf, (HANDLE proc));
+EXTERN_DECL(char * process_errbuf, (HANDLE proc));
+EXTERN_DECL(int process_outcnt, (HANDLE proc));
+EXTERN_DECL(int process_errcnt, (HANDLE proc));
+EXTERN_DECL(void process_pipes, (HANDLE proc, int pipes[3]));
+EXTERN_DECL(void process_noinherit, (int fildes));
+
+#endif
diff --git a/src/kmk/w32/include/w32err.h b/src/kmk/w32/include/w32err.h
new file mode 100644
index 0000000..b4292f2
--- /dev/null
+++ b/src/kmk/w32/include/w32err.h
@@ -0,0 +1,26 @@
+/* Definitions for Windows error handling.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef _W32ERR_H_
+#define _W32ERR_H_
+
+#ifndef EXTERN_DECL
+#define EXTERN_DECL(entry, args) entry args
+#endif
+
+EXTERN_DECL(const char * map_windows32_error_to_string, (DWORD error));
+
+#endif /* !_W32ERR_H */
diff --git a/src/kmk/w32/pathstuff.c b/src/kmk/w32/pathstuff.c
new file mode 100644
index 0000000..f80cbf1
--- /dev/null
+++ b/src/kmk/w32/pathstuff.c
@@ -0,0 +1,321 @@
+/* Path conversion for Windows pathnames.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "makeint.h"
+#include <string.h>
+#include <stdlib.h>
+#include "pathstuff.h"
+#if 1 /* bird */
+# include "nt_fullpath.h"
+# include <assert.h>
+#endif
+
+/*
+ * Convert delimiter separated vpath to Canonical format.
+ */
+char *
+convert_vpath_to_windows32(char *Path, char to_delim)
+{
+    char *etok;            /* token separator for old Path */
+
+        /*
+         * Convert all spaces to delimiters. Note that pathnames which
+         * contain blanks get trounced here. Use 8.3 format as a workaround.
+         */
+        for (etok = Path; etok && *etok; etok++)
+                if (ISBLANK ((unsigned char) *etok))
+                        *etok = to_delim;
+
+        return (convert_Path_to_windows32(Path, to_delim));
+}
+
+/*
+ * Convert delimiter separated path to Canonical format.
+ */
+char *
+convert_Path_to_windows32(char *Path, char to_delim)
+{
+    char *etok;            /* token separator for old Path */
+    char *p;            /* points to element of old Path */
+
+    /* is this a multi-element Path ? */
+    /* FIXME: Perhaps use ":;\"" in strpbrk to convert all quotes to
+       delimiters as well, as a way to handle quoted directories in
+       PATH?  */
+    for (p = Path, etok = strpbrk(p, ":;");
+         etok;
+         etok = strpbrk(p, ":;"))
+        if ((etok - p) == 1) {
+            if (*(etok - 1) == ';' ||
+                *(etok - 1) == ':') {
+                etok[-1] = to_delim;
+                etok[0] = to_delim;
+                p = ++etok;
+                continue;    /* ignore empty bucket */
+            } else if (!isalpha ((unsigned char) *p)) {
+                /* found one to count, handle things like '.' */
+                *etok = to_delim;
+                p = ++etok;
+            } else if ((*etok == ':') && (etok = strpbrk(etok+1, ":;"))) {
+                /* found one to count, handle drive letter */
+                *etok = to_delim;
+                p = ++etok;
+            } else
+                /* all finished, force abort */
+                p += strlen(p);
+        } else if (*p == '"') { /* a quoted directory */
+            for (p++; *p && *p != '"'; p++) /* skip quoted part */
+                ;
+            etok = strpbrk(p, ":;");        /* find next delimiter */
+            if (etok) {
+                *etok = to_delim;
+                p = ++etok;
+            } else
+                p += strlen(p);
+        } else {
+            /* found another one, no drive letter */
+            *etok = to_delim;
+            p = ++etok;
+        }
+
+    return Path;
+}
+
+/*
+ * Convert to forward slashes directly (w32ify(filename, 0)).
+ */
+char *unix_slashes(char *filename) /* bird */
+{
+    char *slash = filename ;
+    while ((slash = strchr(slash, '\\')) != NULL)
+        *slash++ = '/';
+    return filename;
+}
+
+/*
+ * Resolve and convert to forward slashes directly (w32ify(filename, 1)).
+ * Returns if out of buffer space.
+ */
+char *unix_slashes_resolved(const char *src, char *dst, unsigned len)
+{
+    assert(len >= FILENAME_MAX);
+    *dst = '\0'; /** @todo nt_fullpath_cached needs to return some indication of overflow. */
+#if 1
+    nt_fullpath_cached(src, dst, len);
+#else
+    _fullpath(dst, src, len);
+#endif
+
+    return unix_slashes(dst);
+}
+
+#if 0 /* bird: replaced by unix_slashes and unix_slahes_resolved. */
+/*
+ * Convert to forward slashes. Resolve to full pathname optionally
+ */
+char *
+w32ify(const char *filename, int resolve)
+{
+    static char w32_path[FILENAME_MAX];
+#if 1 /* bird */
+
+    if (resolve) {
+        nt_fullpath_cached(filename, w32_path, sizeof(w32_path));
+    } else {
+        w32_path[0] = '\0';
+        strncat(w32_path, filename, sizeof(w32_path));
+    }
+    return unix_slashes(w32_path);
+
+#else   /* !bird */
+    char *p;
+
+    if (resolve) {
+        _fullpath(w32_path, filename, sizeof (w32_path));
+    } else
+        strncpy(w32_path, filename, sizeof (w32_path));
+
+    for (p = w32_path; p && *p; p++)
+        if (*p == '\\')
+            *p = '/';
+
+    return w32_path;
+#endif  /* !bird */
+}
+#endif
+
+char *
+getcwd_fs(char* buf, int len)
+{
+        char *p = getcwd(buf, len);
+
+        if (p) {
+#if 1
+                p = unix_slashes(p);
+#else
+                char *q = w32ify(buf, 0);
+#if 1  /* bird - UPSTREAM? */
+                buf[0] = '\0';
+                strncat(buf, q, len);
+#else  /* !bird */
+                strncpy(buf, q, len);
+#endif
+#endif
+        }
+
+        return p;
+}
+
+#ifdef unused
+/*
+ * Convert delimiter separated pathnames (e.g. PATH) or single file pathname
+ * (e.g. c:/foo, c:\bar) to NutC format. If we are handed a string that
+ * _NutPathToNutc() fails to convert, just return the path we were handed
+ * and assume the caller will know what to do with it (It was probably
+ * a mistake to try and convert it anyway due to some of the bizarre things
+ * that might look like pathnames in makefiles).
+ */
+char *
+convert_path_to_nutc(char *path)
+{
+    int  count;            /* count of path elements */
+    char *nutc_path;     /* new NutC path */
+    int  nutc_path_len;    /* length of buffer to allocate for new path */
+    char *pathp;        /* pointer to nutc_path used to build it */
+    char *etok;            /* token separator for old path */
+    char *p;            /* points to element of old path */
+    char sep;            /* what flavor of separator used in old path */
+    char *rval;
+
+    /* is this a multi-element path ? */
+    for (p = path, etok = strpbrk(p, ":;"), count = 0;
+         etok;
+         etok = strpbrk(p, ":;"))
+        if ((etok - p) == 1) {
+            if (*(etok - 1) == ';' ||
+                *(etok - 1) == ':') {
+                p = ++etok;
+                continue;    /* ignore empty bucket */
+            } else if (etok = strpbrk(etok+1, ":;"))
+                /* found one to count, handle drive letter */
+                p = ++etok, count++;
+            else
+                /* all finished, force abort */
+                p += strlen(p);
+        } else
+            /* found another one, no drive letter */
+            p = ++etok, count++;
+
+    if (count) {
+        count++;    /* x1;x2;x3 <- need to count x3 */
+
+        /*
+         * Hazard a guess on how big the buffer needs to be.
+         * We have to convert things like c:/foo to /c=/foo.
+         */
+        nutc_path_len = strlen(path) + (count*2) + 1;
+        nutc_path = xmalloc(nutc_path_len);
+        pathp = nutc_path;
+        *pathp = '\0';
+
+        /*
+         * Loop through PATH and convert one elemnt of the path at at
+         * a time. Single file pathnames will fail this and fall
+         * to the logic below loop.
+         */
+        for (p = path, etok = strpbrk(p, ":;");
+             etok;
+             etok = strpbrk(p, ":;")) {
+
+            /* don't trip up on device specifiers or empty path slots */
+            if ((etok - p) == 1)
+                if (*(etok - 1) == ';' ||
+                    *(etok - 1) == ':') {
+                    p = ++etok;
+                    continue;
+                } else if ((etok = strpbrk(etok+1, ":;")) == NULL)
+                    break;    /* thing found was a WINDOWS32 pathname */
+
+            /* save separator */
+            sep = *etok;
+
+            /* terminate the current path element -- temporarily */
+            *etok = '\0';
+
+#ifdef __NUTC__
+            /* convert to NutC format */
+            if (_NutPathToNutc(p, pathp, 0) == FALSE) {
+                free(nutc_path);
+                rval = savestring(path, strlen(path));
+                return rval;
+            }
+#else
+            *pathp++ = '/';
+            *pathp++ = p[0];
+            *pathp++ = '=';
+            *pathp++ = '/';
+            strcpy(pathp, &p[2]);
+#endif
+
+            pathp += strlen(pathp);
+            *pathp++ = ':';     /* use Unix style path separtor for new path */
+            *pathp   = '\0'; /* make sure we are null terminaed */
+
+            /* restore path separator */
+            *etok = sep;
+
+            /* point p to first char of next path element */
+            p = ++etok;
+
+        }
+    } else {
+        nutc_path_len = strlen(path) + 3;
+        nutc_path = xmalloc(nutc_path_len);
+        pathp = nutc_path;
+        *pathp = '\0';
+        p = path;
+    }
+
+    /*
+      * OK, here we handle the last element in PATH (e.g. c of a;b;c)
+     * or the path was a single filename and will be converted
+     * here. Note, testing p here assures that we don't trip up
+     * on paths like a;b; which have trailing delimiter followed by
+     * nothing.
+     */
+    if (*p != '\0') {
+#ifdef __NUTC__
+        if (_NutPathToNutc(p, pathp, 0) == FALSE) {
+            free(nutc_path);
+            rval = savestring(path, strlen(path));
+            return rval;
+        }
+#else
+        *pathp++ = '/';
+        *pathp++ = p[0];
+        *pathp++ = '=';
+        *pathp++ = '/';
+        strcpy(pathp, &p[2]);
+#endif
+    } else
+        *(pathp-1) = '\0'; /* we're already done, don't leave trailing : */
+
+    rval = savestring(nutc_path, strlen(nutc_path));
+    free(nutc_path);
+    return rval;
+}
+
+#endif
diff --git a/src/kmk/w32/subproc/Makefile.kup b/src/kmk/w32/subproc/Makefile.kup
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/kmk/w32/subproc/Makefile.kup
diff --git a/src/kmk/w32/subproc/NMakefile b/src/kmk/w32/subproc/NMakefile
new file mode 100644
index 0000000..325e55c
--- /dev/null
+++ b/src/kmk/w32/subproc/NMakefile
@@ -0,0 +1,60 @@
+# NOTE: If you have no 'make' program at all to process this makefile, run
+# 'build.bat' instead.
+#
+# Copyright (C) 1996-2016 Free Software Foundation, Inc.
+# This file is part of GNU Make.
+#
+# GNU Make is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option) any later
+# version.
+#
+# GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#
+#       NMakefile for GNU Make (subproc library)
+#
+LIB = lib
+CC = cl
+MAKE = nmake
+
+OUTDIR=.
+MAKEFILE=NMakefile
+
+CFLAGS_any = /nologo /MT /W4 /GX /Z7 /YX /D WIN32 /D WINDOWS32 /D _WINDOWS  -I. -I../include -I../../
+CFLAGS_debug = $(CFLAGS_any) /Od /D _DEBUG /FR.\WinDebug\ /Fp.\WinDebug\subproc.pch /Fo.\WinDebug/
+CFLAGS_release = $(CFLAGS_any) /O2 /FR.\WinRel\ /Fp.\WinRel\subproc.pch /Fo.\WinRel/
+
+all: Release Debug
+
+Release:
+	$(MAKE) /f $(MAKEFILE) OUTDIR=WinRel CFLAGS="$(CFLAGS_release)" WinRel/subproc.lib
+Debug:
+	$(MAKE) /f $(MAKEFILE) OUTDIR=WinDebug CFLAGS="$(CFLAGS_debug)" WinDebug/subproc.lib
+
+clean:
+	rmdir /s /q WinRel WinDebug
+	erase *.pdb
+
+$(OUTDIR):
+	if not exist .\$@\nul mkdir .\$@
+
+OBJS = $(OUTDIR)/misc.obj $(OUTDIR)/w32err.obj $(OUTDIR)/sub_proc.obj
+
+$(OUTDIR)/subproc.lib: $(OUTDIR) $(OBJS)
+	$(LIB) -out:$@ @<<
+		$(OBJS)
+<<
+
+.c{$(OUTDIR)}.obj:
+	$(CC) $(CFLAGS) /c $<
+
+$(OUTDIR)/misc.obj: misc.c proc.h
+$(OUTDIR)/sub_proc.obj: sub_proc.c  ../include/sub_proc.h ../include/w32err.h proc.h
+$(OUTDIR)/w32err.obj: w32err.c ../include/w32err.h
diff --git a/src/kmk/w32/subproc/misc.c b/src/kmk/w32/subproc/misc.c
new file mode 100644
index 0000000..8b17413
--- /dev/null
+++ b/src/kmk/w32/subproc/misc.c
@@ -0,0 +1,83 @@
+/* Process handling for Windows
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include "proc.h"
+
+
+/*
+ * Description:  Convert a NULL string terminated UNIX environment block to
+ *              an environment block suitable for a windows32 system call
+ *
+ * Returns:  TRUE= success, FALSE=fail
+ *
+ * Notes/Dependencies:  the environment block is sorted in case-insensitive
+ *      order, is double-null terminated, and is a char *, not a char **
+ */
+int _cdecl compare(const void *a1, const void *a2)
+{
+        return _stricoll(*((char**)a1),*((char**)a2));
+}
+bool_t
+arr2envblk(char **arr, char **envblk_out, int *envsize_needed)
+{
+        char **tmp;
+        int size_needed;
+        int arrcnt;
+        char *ptr;
+
+        arrcnt = 0;
+        while (arr[arrcnt]) {
+                arrcnt++;
+        }
+
+        tmp = (char**) calloc(arrcnt + 1, sizeof(char *));
+        if (!tmp) {
+                return FALSE;
+        }
+
+        arrcnt = 0;
+        size_needed = *envsize_needed = 0;
+        while (arr[arrcnt]) {
+                tmp[arrcnt] = arr[arrcnt];
+                size_needed += strlen(arr[arrcnt]) + 1;
+                arrcnt++;
+        }
+        size_needed++;
+        *envsize_needed = size_needed;
+
+        qsort((void *) tmp, (size_t) arrcnt, sizeof (char*), compare);
+
+        ptr = *envblk_out = calloc(size_needed, 1);
+        if (!ptr) {
+                free(tmp);
+                return FALSE;
+        }
+
+        arrcnt = 0;
+        while (tmp[arrcnt]) {
+                strcpy(ptr, tmp[arrcnt]);
+                ptr += strlen(tmp[arrcnt]) + 1;
+                arrcnt++;
+        }
+
+        free(tmp);
+        return TRUE;
+}
diff --git a/src/kmk/w32/subproc/proc.h b/src/kmk/w32/subproc/proc.h
new file mode 100644
index 0000000..7ccb5ea
--- /dev/null
+++ b/src/kmk/w32/subproc/proc.h
@@ -0,0 +1,29 @@
+/* Definitions for Windows
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef  _PROC_H
+#define _PROC_H
+
+typedef int bool_t;
+
+#define E_SCALL         101
+#define E_IO            102
+#define E_NO_MEM        103
+#define E_FORK          104
+
+extern bool_t arr2envblk(char **arr, char **envblk_out, int *envsize_needed);
+
+#endif
diff --git a/src/kmk/w32/subproc/sub_proc.c b/src/kmk/w32/subproc/sub_proc.c
new file mode 100644
index 0000000..6ccfa47
--- /dev/null
+++ b/src/kmk/w32/subproc/sub_proc.c
@@ -0,0 +1,1714 @@
+/* Process handling for Windows.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <io.h>         /* for _get_osfhandle */
+#ifdef _MSC_VER
+# include <stddef.h>    /* for intptr_t */
+#else
+# include <stdint.h>
+#endif
+#include <string.h>
+#include <process.h>  /* for msvc _beginthreadex, _endthreadex */
+#include <signal.h>
+#include <windows.h>
+
+#include "makeint.h"
+#include "filedef.h"
+#include "variable.h"
+#include "sub_proc.h"
+#include "proc.h"
+#include "w32err.h"
+#include "debug.h"
+
+#ifdef KMK
+# include <assert.h>
+# include "kmkbuiltin.h"
+extern void kmk_cache_exec_image_a(const char *); /* imagecache.c */
+#endif
+
+static char *make_command_line(char *shell_name, char *exec_path, char **argv);
+
+typedef struct sub_process_t {
+#ifdef KMK
+        enum { kRegular = 0, kSubmit, kSubProcFreed } enmType;
+        intptr_t clue;
+#endif
+        intptr_t sv_stdin[2];
+        intptr_t sv_stdout[2];
+        intptr_t sv_stderr[2];
+        int using_pipes;
+        char *inp;
+        DWORD incnt;
+        char * volatile outp;
+        volatile DWORD outcnt;
+        char * volatile errp;
+        volatile DWORD errcnt;
+        pid_t pid;
+        int exit_code;
+        int signal;
+        long last_err;
+        long lerrno;
+} sub_process;
+
+static long process_file_io_private(sub_process *pproc, BOOL fNeedToWait); /* bird */
+
+/* keep track of children so we can implement a waitpid-like routine */
+static sub_process *proc_array[MAXIMUM_WAIT_OBJECTS];
+static int proc_index = 0;
+static int fake_exits_pending = 0;
+
+
+/*
+ * Fill a HANDLE list with handles to wait for.
+ */
+DWORD
+process_set_handles(HANDLE *handles)
+{
+    DWORD count = 0;
+    int i;
+
+    /* Build array of handles to wait for */
+    for (i = 0; i < proc_index; i++) {
+        /* Don't wait on child processes that have already finished */
+        if (fake_exits_pending && proc_array[i]->exit_code)
+            continue;
+
+        handles[count++] = (HANDLE) proc_array[i]->pid;
+    }
+
+    return count;
+}
+
+#ifndef KMK /* Inefficient! */
+/*
+ * When a process has been waited for, adjust the wait state
+ * array so that we don't wait for it again
+ */
+static void
+process_adjust_wait_state(sub_process* pproc)
+{
+        int i;
+
+        if (!proc_index)
+                return;
+
+        for (i = 0; i < proc_index; i++)
+                if (proc_array[i]->pid == pproc->pid)
+                        break;
+
+        if (i < proc_index) {
+                proc_index--;
+                if (i != proc_index)
+                        memmove(&proc_array[i], &proc_array[i+1],
+                                (proc_index-i) * sizeof(sub_process*));
+                proc_array[proc_index] = NULL;
+        }
+}
+
+#endif /* !KMK */
+
+/*
+ * Waits for any of the registered child processes to finish.
+ */
+static sub_process *
+process_wait_for_any_private(int block, DWORD* pdwWaitStatus)
+{
+        HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+        DWORD retval, which;
+        int i;
+
+        if (!proc_index)
+                return NULL;
+
+        /* build array of handles to wait for */
+        for (i = 0; i < proc_index; i++) {
+                handles[i] = (HANDLE) proc_array[i]->pid;
+
+                if (fake_exits_pending && proc_array[i]->exit_code)
+                        break;
+        }
+
+        /* wait for someone to exit */
+        if (!fake_exits_pending) {
+#ifdef KMK
+l_wait_again:
+#endif
+                retval = WaitForMultipleObjects(proc_index, handles, FALSE, (block ? INFINITE : 0));
+                which = retval - WAIT_OBJECT_0;
+        } else {
+                fake_exits_pending--;
+                retval = !WAIT_FAILED;
+                which = i;
+        }
+
+        /* If the pointer is not NULL, set the wait status result variable. */
+        if (pdwWaitStatus)
+            *pdwWaitStatus = retval;
+
+        /* return pointer to process */
+        if ((retval == WAIT_TIMEOUT) || (retval == WAIT_FAILED)) {
+                return NULL;
+        }
+        else {
+                sub_process* pproc = proc_array[which];
+#ifdef KMK
+                if (pproc->enmType == kSubmit) {
+                        /* Try get the result from kSubmit.c.  This may not succeed if the whole
+                           result hasn't arrived yet, in which we just restart the wait. */
+                        if (kSubmitSubProcGetResult(pproc->clue, &pproc->exit_code, &pproc->signal) != 0) {
+                                goto l_wait_again;
+                        }
+                }
+#endif
+#ifndef KMK /* Inefficient! */
+                process_adjust_wait_state(pproc);
+#else
+                proc_index--;
+                if ((int)which < proc_index)
+                        proc_array[which] = proc_array[proc_index];
+                proc_array[proc_index] = NULL;
+#endif
+                return pproc;
+        }
+}
+
+/*
+ * Terminate a process.
+ */
+BOOL
+ process_kill(HANDLE proc, int signal)
+{
+        sub_process* pproc = (sub_process*) proc;
+#ifdef KMK
+    if (pproc->enmType == kRegular) {
+#endif
+        pproc->signal = signal;
+        return (TerminateProcess((HANDLE) pproc->pid, signal));
+#ifdef KMK
+    } else if (pproc->enmType == kSubmit)
+        return kSubmitSubProcKill(pproc->clue, signal) == 0;
+    assert(0);
+    return FALSE;
+#endif
+}
+
+/*
+ * Use this function to register processes you wish to wait for by
+ * calling process_file_io(NULL) or process_wait_any(). This must be done
+ * because it is possible for callers of this library to reuse the same
+ * handle for multiple processes launches :-(
+ */
+void
+process_register(HANDLE proc)
+{
+#ifdef KMK
+        assert(((sub_process *)proc)->enmType == kRegular);
+#endif
+        if (proc_index < MAXIMUM_WAIT_OBJECTS)
+                proc_array[proc_index++] = (sub_process *) proc;
+}
+
+#ifdef KMK
+
+/**
+ * Interface used by kmkbuiltin/kSubmit.c to register stuff going down in a
+ * worker process.
+ *
+ * @returns 0 on success, -1 if there are too many sub-processes already.
+ * @param   hEvent              The event semaphore to wait on.
+ * @param   clue                The clue to base.
+ * @param   pPid                Where to return the pid that job.c expects.
+ */
+int
+process_kmk_register_submit(HANDLE hEvent, intptr_t clue, pid_t *pPid)
+{
+	if (proc_index < MAXIMUM_WAIT_OBJECTS) {
+		sub_process *pSubProc = (sub_process *)xcalloc(sizeof(*pSubProc));
+		pSubProc->enmType = kSubmit;
+		pSubProc->clue    = clue;
+		pSubProc->pid     = (intptr_t)hEvent;
+
+		proc_array[proc_index++] = pSubProc;
+		*pPid = (intptr_t)pSubProc;
+		return 0;
+	}
+	return -1;
+}
+
+/**
+ * Interface used by kmkbuiltin/kRedirect.c to register a spawned process.
+ *
+ * @returns 0 on success, -1 if there are too many sub-processes already.
+ * @param   hProcess            The process handle.
+ * @param   pPid                Where to return the pid that job.c expects.
+ */
+int
+process_kmk_register_redirect(HANDLE hProcess, pid_t *pPid)
+{
+	if (proc_index < MAXIMUM_WAIT_OBJECTS) {
+		sub_process *pSubProc = (sub_process *)xcalloc(sizeof(*pSubProc));
+		pSubProc->enmType = kRegular;
+		pSubProc->pid     = (intptr_t)hProcess;
+
+		proc_array[proc_index++] = pSubProc;
+		*pPid = (intptr_t)pSubProc;
+		return 0;
+	}
+	return -1;
+}
+
+#endif /* KMK */
+
+/*
+ * Return the number of processes that we are still waiting for.
+ */
+int
+process_used_slots(void)
+{
+        return proc_index;
+}
+
+/*
+ * Public function which works kind of like waitpid(). Wait for any
+ * of the children to die and return results. To call this function,
+ * you must do 1 of things:
+ *
+ *      x = process_easy(...);
+ *
+ * or
+ *
+ *      x = process_init_fd();
+ *      process_register(x);
+ *
+ * or
+ *
+ *      x = process_init();
+ *      process_register(x);
+ *
+ * You must NOT then call process_pipe_io() because this function is
+ * not capable of handling automatic notification of any child
+ * death.
+ */
+
+HANDLE
+process_wait_for_any(int block, DWORD* pdwWaitStatus)
+{
+        sub_process* pproc = process_wait_for_any_private(block, pdwWaitStatus);
+
+        if (!pproc)
+                return NULL;
+        else {
+                /*
+                 * Ouch! can't tell caller if this fails directly. Caller
+                 * will have to use process_last_err()
+                 */
+#ifdef KMK
+                /* Invalidate negative directory cache entries now that a
+                   job has completed and possibly created new files that
+                   was missing earlier. */
+                dir_cache_invalid_after_job ();
+
+                if (pproc->enmType == kRegular) {
+                        (void)process_file_io_private(pproc, FALSE);
+                }
+#else
+                (void) process_file_io(pproc);
+#endif
+                return ((HANDLE) pproc);
+        }
+}
+
+long
+process_signal(HANDLE proc)
+{
+        if (proc == INVALID_HANDLE_VALUE) return 0;
+        return (((sub_process *)proc)->signal);
+}
+
+long
+process_last_err(HANDLE proc)
+{
+        if (proc == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
+        return (((sub_process *)proc)->last_err);
+}
+
+long
+process_exit_code(HANDLE proc)
+{
+        if (proc == INVALID_HANDLE_VALUE) return EXIT_FAILURE;
+        return (((sub_process *)proc)->exit_code);
+}
+
+void
+process_noinherit(int fd)
+{
+  HANDLE fh = (HANDLE)_get_osfhandle(fd);
+
+  if (fh && fh != INVALID_HANDLE_VALUE)
+        SetHandleInformation(fh, HANDLE_FLAG_INHERIT, 0);
+}
+
+/*
+2006-02:
+All the following functions are currently unused.
+All of them would crash gmake if called with argument INVALID_HANDLE_VALUE.
+Hence whoever wants to use one of this functions must invent and implement
+a reasonable error handling for this function.
+
+char *
+process_outbuf(HANDLE proc)
+{
+        return (((sub_process *)proc)->outp);
+}
+
+char *
+process_errbuf(HANDLE proc)
+{
+        return (((sub_process *)proc)->errp);
+}
+
+int
+process_outcnt(HANDLE proc)
+{
+        return (((sub_process *)proc)->outcnt);
+}
+
+int
+process_errcnt(HANDLE proc)
+{
+        return (((sub_process *)proc)->errcnt);
+}
+
+void
+process_pipes(HANDLE proc, int pipes[3])
+{
+        pipes[0] = ((sub_process *)proc)->sv_stdin[0];
+        pipes[1] = ((sub_process *)proc)->sv_stdout[0];
+        pipes[2] = ((sub_process *)proc)->sv_stderr[0];
+        return;
+}
+*/
+
+        HANDLE
+process_init()
+{
+        sub_process *pproc;
+        /*
+         * open file descriptors for attaching stdin/stdout/sterr
+         */
+        HANDLE stdin_pipes[2];
+        HANDLE stdout_pipes[2];
+        HANDLE stderr_pipes[2];
+        SECURITY_ATTRIBUTES inherit;
+        BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
+
+        pproc = malloc(sizeof(*pproc));
+        memset(pproc, 0, sizeof(*pproc));
+
+        /* We can't use NULL for lpSecurityDescriptor because that
+           uses the default security descriptor of the calling process.
+           Instead we use a security descriptor with no DACL.  This
+           allows nonrestricted access to the associated objects. */
+
+        if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
+                                          SECURITY_DESCRIPTOR_REVISION)) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+
+        inherit.nLength = sizeof(inherit);
+        inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
+        inherit.bInheritHandle = TRUE;
+
+        // By convention, parent gets pipe[0], and child gets pipe[1]
+        // This means the READ side of stdin pipe goes into pipe[1]
+        // and the WRITE side of the stdout and stderr pipes go into pipe[1]
+        if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
+        CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
+        CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
+
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+
+        //
+        // Mark the parent sides of the pipes as non-inheritable
+        //
+        if (SetHandleInformation(stdin_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
+                SetHandleInformation(stdout_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
+                SetHandleInformation(stderr_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE) {
+
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+        pproc->sv_stdin[0]  = (intptr_t) stdin_pipes[0];
+        pproc->sv_stdin[1]  = (intptr_t) stdin_pipes[1];
+        pproc->sv_stdout[0] = (intptr_t) stdout_pipes[0];
+        pproc->sv_stdout[1] = (intptr_t) stdout_pipes[1];
+        pproc->sv_stderr[0] = (intptr_t) stderr_pipes[0];
+        pproc->sv_stderr[1] = (intptr_t) stderr_pipes[1];
+
+        pproc->using_pipes = 1;
+
+        pproc->lerrno = 0;
+
+        return((HANDLE)pproc);
+}
+
+
+        HANDLE
+process_init_fd(HANDLE stdinh, HANDLE stdouth, HANDLE stderrh)
+{
+        sub_process *pproc;
+
+        pproc = malloc(sizeof(*pproc));
+        if (pproc) {
+                memset(pproc, 0, sizeof(*pproc));
+
+                /*
+                 * Just pass the provided file handles to the 'child
+                 * side' of the pipe, bypassing pipes altogether.
+                 */
+                pproc->sv_stdin[1]  = (intptr_t) stdinh;
+                pproc->sv_stdout[1] = (intptr_t) stdouth;
+                pproc->sv_stderr[1] = (intptr_t) stderrh;
+
+                pproc->last_err = pproc->lerrno = 0;
+        }
+
+        return((HANDLE)pproc);
+}
+
+
+static HANDLE
+find_file(const char *exec_path, const char *path_var,
+          char *full_fname, DWORD full_len)
+{
+        HANDLE exec_handle;
+        char *fname;
+        char *ext;
+        DWORD req_len;
+        int i;
+        static const char *extensions[] =
+          /* Should .com come before no-extension case?  */
+          { ".exe", ".cmd", ".bat", "", ".com", NULL };
+
+        fname = xmalloc(strlen(exec_path) + 5);
+        strcpy(fname, exec_path);
+        ext = fname + strlen(fname);
+
+        for (i = 0; extensions[i]; i++) {
+                strcpy(ext, extensions[i]);
+                if (((req_len = SearchPath (path_var, fname, NULL, full_len,
+                                            full_fname, NULL)) > 0
+                     /* For compatibility with previous code, which
+                        used OpenFile, and with Windows operation in
+                        general, also look in various default
+                        locations, such as Windows directory and
+                        Windows System directory.  Warning: this also
+                        searches PATH in the Make's environment, which
+                        might not be what the Makefile wants, but it
+                        seems to be OK as a fallback, after the
+                        previous SearchPath failed to find on child's
+                        PATH.  */
+                     || (req_len = SearchPath (NULL, fname, NULL, full_len,
+                                               full_fname, NULL)) > 0)
+                    && req_len <= full_len
+                    && (exec_handle =
+                                CreateFile(full_fname,
+                                           GENERIC_READ,
+                                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                           NULL,
+                                           OPEN_EXISTING,
+                                           FILE_ATTRIBUTE_NORMAL,
+                                           NULL)) != INVALID_HANDLE_VALUE) {
+                        free(fname);
+                        return(exec_handle);
+                }
+        }
+
+        free(fname);
+        return INVALID_HANDLE_VALUE;
+}
+
+/*
+ * Return non-zero of FNAME specifies a batch file and its name
+ * includes embedded whitespace.
+ */
+
+static int
+batch_file_with_spaces(const char *fname)
+{
+        size_t fnlen = strlen(fname);
+
+        return (fnlen > 4
+                && (_strnicmp(fname + fnlen - 4, ".bat", 4) == 0
+                    || _strnicmp(fname + fnlen - 4, ".cmd", 4) == 0)
+                /* The set of characters in the 2nd arg to strpbrk
+                   should be the same one used by make_command_line
+                   below to decide whether an argv[] element needs
+                   quoting.  */
+                && strpbrk(fname, " \t") != NULL);
+}
+
+
+/*
+ * Description:   Create the child process to be helped
+ *
+ * Returns: success <=> 0
+ *
+ * Notes/Dependencies:
+ */
+long
+process_begin(
+        HANDLE proc,
+        char **argv,
+        char **envp,
+        char *exec_path,
+        char *as_user)
+{
+        sub_process *pproc = (sub_process *)proc;
+        char *shell_name = 0;
+        int file_not_found=0;
+        HANDLE exec_handle;
+        char exec_fname[MAX_PATH];
+        const char *path_var = NULL;
+        char **ep;
+        char buf[MAX_PATH];
+        DWORD bytes_returned;
+        DWORD flags;
+        char *command_line;
+        STARTUPINFO startInfo;
+        PROCESS_INFORMATION procInfo;
+        char *envblk=NULL;
+        int envsize_needed = 0;
+        int pass_null_exec_path = 0;
+#ifdef KMK
+        size_t exec_path_len;
+	extern int process_priority;
+
+	assert (pproc->enmType == kRegular);
+#endif
+
+        /*
+         *  Shell script detection...  if the exec_path starts with #! then
+         *  we want to exec shell-script-name exec-path, not just exec-path
+         *  NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl.  We do not
+         *  hard-code the path to the shell or perl or whatever:  Instead, we
+         *  assume it's in the path somewhere (generally, the NT tools
+         *  bin directory)
+         */
+
+#ifdef KMK
+        /* kmk performance: Don't bother looking for shell scripts in .exe files. */
+        exec_path_len = strlen(exec_path);
+        if (exec_path_len > 4
+            && exec_path[exec_path_len - 4] == '.'
+            && !stricmp(exec_path + exec_path_len - 3, "exe")) {
+                exec_handle =  INVALID_HANDLE_VALUE;
+		exec_fname[0] = '\0';
+        }
+        else {
+#endif /* KMK */
+
+        /* Use the Makefile's value of PATH to look for the program to
+           execute, because it could be different from Make's PATH
+           (e.g., if the target sets its own value.  */
+        if (envp)
+                for (ep = envp; *ep; ep++) {
+                        if (strncmp (*ep, "PATH=", 5) == 0
+                            || strncmp (*ep, "Path=", 5) == 0) {
+                                path_var = *ep + 5;
+                                break;
+                        }
+                }
+        exec_handle = find_file(exec_path, path_var,
+                                exec_fname, sizeof(exec_fname));
+#ifdef KMK
+        }
+#endif
+
+        /*
+         * If we couldn't open the file, just assume that Windows will be
+         * somehow able to find and execute it.  If the first character
+         * of the command is '/', assume they set SHELL to a Unixy shell
+         * that have some magic mounts known only to it, and run the whole
+         * command via $SHELL -c "COMMAND" instead.
+         */
+        if (exec_handle == INVALID_HANDLE_VALUE) {
+                if (exec_path[0] == '/') {
+                        char *new_argv0;
+                        char **argvi = argv;
+                        int arglen = 0;
+
+                        strcpy(buf, variable_expand ("$(SHELL)"));
+                        shell_name = &buf[0];
+                        strcpy(exec_fname, "-c");
+                        /* Construct a single command string in argv[0].  */
+                        while (*argvi) {
+                                arglen += strlen(*argvi) + 1;
+                                argvi++;
+                        }
+                        new_argv0 = xmalloc(arglen + 1);
+                        new_argv0[0] = '\0';
+                        for (argvi = argv; *argvi; argvi++) {
+                                strcat(new_argv0, *argvi);
+                                strcat(new_argv0, " ");
+                        }
+                        /* Remove the extra blank at the end.  */
+                        new_argv0[arglen-1] = '\0';
+                        free(argv[0]);
+                        argv[0] = new_argv0;
+                        argv[1] = NULL;
+                }
+                else
+                        file_not_found++;
+        }
+        else {
+                /* Attempt to read the first line of the file */
+                if (ReadFile( exec_handle,
+                                buf, sizeof(buf) - 1, /* leave room for trailing NULL */
+                                &bytes_returned, 0) == FALSE || bytes_returned < 2) {
+
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_IO;
+                        CloseHandle(exec_handle);
+                        return(-1);
+                }
+                if (buf[0] == '#' && buf[1] == '!') {
+                        /*
+                         *  This is a shell script...  Change the command line from
+                         *      exec_path args to shell_name exec_path args
+                         */
+                        char *p;
+
+                        /*  Make sure buf is NULL terminated */
+                        buf[bytes_returned] = 0;
+                        /*
+                         * Depending on the file system type, etc. the first line
+                         * of the shell script may end with newline or newline-carriage-return
+                         * Whatever it ends with, cut it off.
+                         */
+                        p= strchr(buf, '\n');
+                        if (p)
+                                *p = 0;
+                        p = strchr(buf, '\r');
+                        if (p)
+                                *p = 0;
+
+                        /*
+                         *  Find base name of shell
+                         */
+                        shell_name = strrchr( buf, '/');
+                        if (shell_name) {
+                                shell_name++;
+                        } else {
+                                shell_name = &buf[2];/* skipping "#!" */
+                        }
+
+                }
+                CloseHandle(exec_handle);
+        }
+
+        flags = 0;
+
+        if (file_not_found)
+                command_line = make_command_line( shell_name, exec_path, argv);
+        else {
+                /* If exec_fname includes whitespace, CreateProcess
+                   behaves erratically and unreliably, and often fails
+                   if argv[0] also includes whitespace (and thus will
+                   be quoted by make_command_line below).  So in that
+                   case, we don't pass exec_fname as the 1st arg to
+                   CreateProcess, but instead replace argv[0] with
+                   exec_fname (to keep its leading directories and
+                   extension as found by find_file), and pass NULL to
+                   CreateProcess as its 1st arg.  This works around
+                   the bugs in CreateProcess, which are probably
+                   caused by its passing the command to cmd.exe with
+                   some incorrect quoting.  */
+                if (!shell_name
+                    && batch_file_with_spaces(exec_fname)
+                    && _stricmp(exec_path, argv[0]) == 0) {
+                        char *new_argv, *p;
+                        char **argvi;
+                        int arglen, i;
+                        pass_null_exec_path = 1;
+                        /* Rewrite argv[] replacing argv[0] with exec_fname.  */
+                        for (argvi = argv + 1, arglen = strlen(exec_fname) + 1;
+                             *argvi;
+                             argvi++) {
+                                arglen += strlen(*argvi) + 1;
+                        }
+                        new_argv = xmalloc(arglen);
+                        p = strcpy(new_argv, exec_fname) + strlen(exec_fname) + 1;
+                        for (argvi = argv + 1, i = 1; *argvi; argvi++, i++) {
+                                strcpy(p, *argvi);
+                                argv[i] = p;
+                                p += strlen(*argvi) + 1;
+                        }
+                        argv[i] = NULL;
+                        free (argv[0]);
+                        argv[0] = new_argv;
+                }
+                command_line = make_command_line( shell_name, exec_fname, argv);
+        }
+
+        if ( command_line == NULL ) {
+                pproc->last_err = 0;
+                pproc->lerrno = E_NO_MEM;
+                return(-1);
+        }
+
+        if (envp) {
+                if (arr2envblk(envp, &envblk, &envsize_needed) == FALSE) {
+                        pproc->lerrno = E_NO_MEM;
+                        free( command_line );
+                        if ((pproc->last_err == ERROR_INVALID_PARAMETER
+                             || pproc->last_err == ERROR_MORE_DATA)
+                            && envsize_needed > 32*1024) {
+                                fprintf (stderr, "CreateProcess failed, probably because environment is too large (%d bytes).\n",
+                                         envsize_needed);
+                        }
+                        pproc->last_err = 0;
+                        return(-1);
+                }
+        }
+
+        if (shell_name || file_not_found || pass_null_exec_path) {
+                exec_path = 0;  /* Search for the program in %Path% */
+        } else {
+                exec_path = exec_fname;
+        }
+
+        /*
+         *  Set up inherited stdin, stdout, stderr for child
+         */
+        memset(&startInfo, '\0', sizeof(startInfo));
+        GetStartupInfo(&startInfo);
+#ifndef KMK
+        startInfo.dwFlags = STARTF_USESTDHANDLES;
+#endif
+        startInfo.lpReserved = 0;
+        startInfo.cbReserved2 = 0;
+        startInfo.lpReserved2 = 0;
+#ifndef KMK
+        startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
+        startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
+        startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
+#else
+        if (   ((HANDLE)pproc->sv_stdin[1]  != INVALID_HANDLE_VALUE && pproc->sv_stdin[1])
+            || ((HANDLE)pproc->sv_stdout[1] != INVALID_HANDLE_VALUE && pproc->sv_stdout[1])
+            || ((HANDLE)pproc->sv_stderr[1] != INVALID_HANDLE_VALUE && pproc->sv_stderr[1]) ) {
+                startInfo.dwFlags = STARTF_USESTDHANDLES;
+                startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
+                startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
+                startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
+        } else {
+                startInfo.dwFlags = 0;
+                startInfo.hStdInput = 0;
+                startInfo.hStdOutput = 0;
+                startInfo.hStdError = 0;
+        }
+#endif
+
+        if (as_user) {
+                free(envblk);
+                return -1;
+        } else {
+                DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
+                        exec_path ? exec_path : "NULL",
+                        command_line ? command_line : "NULL"));
+#ifdef KMK
+		if (exec_fname[0])
+			kmk_cache_exec_image_a(exec_fname);
+		else if (exec_path)
+			kmk_cache_exec_image_a(exec_path);
+		else if (argv[0])
+			kmk_cache_exec_image_a(argv[0]);
+
+		switch (process_priority) {
+		case 1: flags |= CREATE_SUSPENDED | IDLE_PRIORITY_CLASS; break;
+		case 2: flags |= CREATE_SUSPENDED | BELOW_NORMAL_PRIORITY_CLASS; break;
+		case 3: flags |= CREATE_SUSPENDED | NORMAL_PRIORITY_CLASS; break;
+		case 4: flags |= CREATE_SUSPENDED | HIGH_PRIORITY_CLASS; break;
+		case 5: flags |= CREATE_SUSPENDED | REALTIME_PRIORITY_CLASS; break;
+		}
+#endif
+                if (CreateProcess(
+                        exec_path,
+                        command_line,
+                        NULL,
+                        0, /* default security attributes for thread */
+                        TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */
+                        flags,
+                        envblk,
+                        0, /* default starting directory */
+                        &startInfo,
+                        &procInfo) == FALSE) {
+
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_FORK;
+                        fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
+                                exec_path ? exec_path : "NULL", command_line);
+                        free(envblk);
+                        free( command_line );
+                        return(-1);
+                }
+#ifdef KMK
+                switch (process_priority) {
+                case 1: SetThreadPriority(procInfo.hThread, THREAD_PRIORITY_IDLE); break;
+                case 2: SetThreadPriority(procInfo.hThread, THREAD_PRIORITY_BELOW_NORMAL); break;
+                case 3: SetThreadPriority(procInfo.hThread, THREAD_PRIORITY_NORMAL); break;
+                case 4: SetThreadPriority(procInfo.hThread, THREAD_PRIORITY_HIGHEST); break;
+                case 5: SetThreadPriority(procInfo.hThread, THREAD_PRIORITY_TIME_CRITICAL); break;
+                }
+                ResumeThread(procInfo.hThread);
+#endif
+        }
+
+        pproc->pid = (pid_t)procInfo.hProcess;
+        /* Close the thread handle -- we'll just watch the process */
+        CloseHandle(procInfo.hThread);
+
+        /* Close the halves of the pipes we don't need */
+        if ((HANDLE)pproc->sv_stdin[1] != INVALID_HANDLE_VALUE && pproc->sv_stdin[1])
+          CloseHandle((HANDLE)pproc->sv_stdin[1]);
+        if ((HANDLE)pproc->sv_stdout[1] != INVALID_HANDLE_VALUE && pproc->sv_stdout[1])
+          CloseHandle((HANDLE)pproc->sv_stdout[1]);
+        if ((HANDLE)pproc->sv_stderr[1] != INVALID_HANDLE_VALUE && pproc->sv_stderr[1])
+          CloseHandle((HANDLE)pproc->sv_stderr[1]);
+        pproc->sv_stdin[1] = 0;
+        pproc->sv_stdout[1] = 0;
+        pproc->sv_stderr[1] = 0;
+
+        free( command_line );
+        free(envblk);
+        pproc->lerrno=0;
+        return 0;
+}
+
+
+
+#if 0   /* unused */
+static DWORD
+proc_stdin_thread(sub_process *pproc)
+{
+        DWORD in_done;
+        for (;;) {
+                if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
+                                         &in_done, NULL) == FALSE)
+                        _endthreadex(0);
+                // This if should never be true for anonymous pipes, but gives
+                // us a chance to change I/O mechanisms later
+                if (in_done < pproc->incnt) {
+                        pproc->incnt -= in_done;
+                        pproc->inp += in_done;
+                } else {
+                        _endthreadex(0);
+                }
+        }
+        return 0; // for compiler warnings only.. not reached
+}
+
+static DWORD
+proc_stdout_thread(sub_process *pproc)
+{
+        DWORD bufsize = 1024;
+        char c;
+        DWORD nread;
+        pproc->outp = malloc(bufsize);
+        if (pproc->outp == NULL)
+                _endthreadex(0);
+        pproc->outcnt = 0;
+
+        for (;;) {
+                if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
+                                        == FALSE) {
+/*                      map_windows32_error_to_string(GetLastError());*/
+                        _endthreadex(0);
+                }
+                if (nread == 0)
+                        _endthreadex(0);
+                if (pproc->outcnt + nread > bufsize) {
+                        bufsize += nread + 512;
+                        pproc->outp = realloc(pproc->outp, bufsize);
+                        if (pproc->outp == NULL) {
+                                pproc->outcnt = 0;
+                                _endthreadex(0);
+                        }
+                }
+                pproc->outp[pproc->outcnt++] = c;
+        }
+        return 0;
+}
+
+static DWORD
+proc_stderr_thread(sub_process *pproc)
+{
+        DWORD bufsize = 1024;
+        char c;
+        DWORD nread;
+        pproc->errp = malloc(bufsize);
+        if (pproc->errp == NULL)
+                _endthreadex(0);
+        pproc->errcnt = 0;
+
+        for (;;) {
+                if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
+                        map_windows32_error_to_string(GetLastError());
+                        _endthreadex(0);
+                }
+                if (nread == 0)
+                        _endthreadex(0);
+                if (pproc->errcnt + nread > bufsize) {
+                        bufsize += nread + 512;
+                        pproc->errp = realloc(pproc->errp, bufsize);
+                        if (pproc->errp == NULL) {
+                                pproc->errcnt = 0;
+                                _endthreadex(0);
+                        }
+                }
+                pproc->errp[pproc->errcnt++] = c;
+        }
+        return 0;
+}
+
+
+/*
+ * Purpose: collects output from child process and returns results
+ *
+ * Description:
+ *
+ * Returns:
+ *
+ * Notes/Dependencies:
+ */
+        long
+process_pipe_io(
+        HANDLE proc,
+        char *stdin_data,
+        int stdin_data_len)
+{
+        sub_process *pproc = (sub_process *)proc;
+        bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
+        HANDLE childhand = (HANDLE) pproc->pid;
+        HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
+        unsigned int dwStdin, dwStdout, dwStderr;
+        HANDLE wait_list[4];
+        DWORD wait_count;
+        DWORD wait_return;
+        HANDLE ready_hand;
+        bool_t child_dead = FALSE;
+        BOOL GetExitCodeResult;
+#ifdef KMK
+	assert (pproc->enmType == kRegular);
+#endif
+
+        /*
+         *  Create stdin thread, if needed
+         */
+        pproc->inp = stdin_data;
+        pproc->incnt = stdin_data_len;
+        if (!pproc->inp) {
+                stdin_eof = TRUE;
+                CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                pproc->sv_stdin[0] = 0;
+        } else {
+                tStdin = (HANDLE) _beginthreadex( 0, 1024,
+                        (unsigned (__stdcall *) (void *))proc_stdin_thread,
+                                                  pproc, 0, &dwStdin);
+                if (tStdin == 0) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_SCALL;
+                        goto done;
+                }
+        }
+
+        /*
+         *   Assume child will produce stdout and stderr
+         */
+        tStdout = (HANDLE) _beginthreadex( 0, 1024,
+                (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
+                &dwStdout);
+        tStderr = (HANDLE) _beginthreadex( 0, 1024,
+                (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
+                &dwStderr);
+
+        if (tStdout == 0 || tStderr == 0) {
+
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                goto done;
+        }
+
+
+        /*
+         *  Wait for all I/O to finish and for the child process to exit
+         */
+
+        while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
+                wait_count = 0;
+                if (!stdin_eof) {
+                        wait_list[wait_count++] = tStdin;
+                }
+                if (!stdout_eof) {
+                        wait_list[wait_count++] = tStdout;
+                }
+                if (!stderr_eof) {
+                        wait_list[wait_count++] = tStderr;
+                }
+                if (!child_dead) {
+                        wait_list[wait_count++] = childhand;
+                }
+
+                wait_return = WaitForMultipleObjects(wait_count, wait_list,
+                         FALSE, /* don't wait for all: one ready will do */
+                         child_dead? 1000 :INFINITE); /* after the child dies, subthreads have
+                                one second to collect all remaining output */
+
+                if (wait_return == WAIT_FAILED) {
+/*                      map_windows32_error_to_string(GetLastError());*/
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_SCALL;
+                        goto done;
+                }
+
+                ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
+
+                if (ready_hand == tStdin) {
+                        CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                        pproc->sv_stdin[0] = 0;
+                        CloseHandle(tStdin);
+                        tStdin = 0;
+                        stdin_eof = TRUE;
+
+                } else if (ready_hand == tStdout) {
+
+                        CloseHandle((HANDLE)pproc->sv_stdout[0]);
+                        pproc->sv_stdout[0] = 0;
+                        CloseHandle(tStdout);
+                        tStdout = 0;
+                        stdout_eof = TRUE;
+
+                } else if (ready_hand == tStderr) {
+
+                        CloseHandle((HANDLE)pproc->sv_stderr[0]);
+                        pproc->sv_stderr[0] = 0;
+                        CloseHandle(tStderr);
+                        tStderr = 0;
+                        stderr_eof = TRUE;
+
+                } else if (ready_hand == childhand) {
+
+                        DWORD ierr;
+                        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
+                        if (ierr == CONTROL_C_EXIT) {
+                                pproc->signal = SIGINT;
+                        } else {
+                                pproc->exit_code = ierr;
+                        }
+                        if (GetExitCodeResult == FALSE) {
+                                pproc->last_err = GetLastError();
+                                pproc->lerrno = E_SCALL;
+                                goto done;
+                        }
+                        child_dead = TRUE;
+
+                } else {
+
+                        /* ?? Got back a handle we didn't query ?? */
+                        pproc->last_err = 0;
+                        pproc->lerrno = E_FAIL;
+                        goto done;
+                }
+        }
+
+ done:
+        if (tStdin != 0)
+                CloseHandle(tStdin);
+        if (tStdout != 0)
+                CloseHandle(tStdout);
+        if (tStderr != 0)
+                CloseHandle(tStderr);
+
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
+
+}
+#endif  /* unused */
+
+#ifndef KMK /* unused */
+/*
+ * Purpose: collects output from child process and returns results
+ *
+ * Description:
+ *
+ * Returns:
+ *
+ * Notes/Dependencies:
+ */
+        long
+process_file_io(
+        HANDLE proc)
+{
+        sub_process *pproc;
+
+        if (proc == NULL)
+                pproc = process_wait_for_any_private(1, 0);
+        else
+                pproc = (sub_process *)proc;
+
+        /* some sort of internal error */
+        if (!pproc)
+                return -1;
+
+	return process_file_io_private(proc, TRUE);
+}
+#endif /* !KMK - unused */
+
+/* private function, avoid some kernel calls. (bird) */
+static long
+process_file_io_private(
+	sub_process *pproc,
+	BOOL fNeedToWait)
+{
+	HANDLE childhand;
+	DWORD wait_return;
+	BOOL GetExitCodeResult;
+	DWORD ierr;
+
+        childhand = (HANDLE) pproc->pid;
+
+        /*
+         * This function is poorly named, and could also be used just to wait
+         * for child death if you're doing your own pipe I/O.  If that is
+         * the case, close the pipe handles here.
+         */
+        if (pproc->sv_stdin[0]) {
+                CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                pproc->sv_stdin[0] = 0;
+        }
+        if (pproc->sv_stdout[0]) {
+                CloseHandle((HANDLE)pproc->sv_stdout[0]);
+                pproc->sv_stdout[0] = 0;
+        }
+        if (pproc->sv_stderr[0]) {
+                CloseHandle((HANDLE)pproc->sv_stderr[0]);
+                pproc->sv_stderr[0] = 0;
+        }
+
+#ifdef KMK
+	if (childhand == NULL || childhand == INVALID_HANDLE_VALUE) {
+		goto done2;
+	}
+#endif
+
+        /*
+         *  Wait for the child process to exit
+         */
+
+    if (fNeedToWait) { /* bird */
+        wait_return = WaitForSingleObject(childhand, INFINITE);
+
+        if (wait_return != WAIT_OBJECT_0) {
+/*              map_windows32_error_to_string(GetLastError());*/
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                goto done2;
+        }
+    } /* bird */
+
+        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
+        if (ierr == CONTROL_C_EXIT) {
+                pproc->signal = SIGINT;
+        } else {
+                pproc->exit_code = ierr;
+        }
+        if (GetExitCodeResult == FALSE) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+        }
+
+done2:
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
+
+}
+
+/*
+ * Description:  Clean up any leftover handles, etc.  It is up to the
+ * caller to manage and free the input, output, and stderr buffers.
+ */
+        void
+process_cleanup(
+        HANDLE proc)
+{
+        sub_process *pproc = (sub_process *)proc;
+        int i;
+
+#ifdef KMK
+    if (pproc->enmType == kRegular) {
+#endif
+        if (pproc->using_pipes) {
+                for (i= 0; i <= 1; i++) {
+                        if ((HANDLE)pproc->sv_stdin[i]
+                            && (HANDLE)pproc->sv_stdin[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stdin[i]);
+                        if ((HANDLE)pproc->sv_stdout[i]
+                            && (HANDLE)pproc->sv_stdout[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stdout[i]);
+                        if ((HANDLE)pproc->sv_stderr[i]
+                            && (HANDLE)pproc->sv_stderr[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stderr[i]);
+                }
+        }
+        if ((HANDLE)pproc->pid)
+                CloseHandle((HANDLE)pproc->pid);
+#ifdef KMK
+    } else if (pproc->enmType == kSubmit) {
+        kSubmitSubProcCleanup(pproc->clue);
+    } else {
+       assert(0);
+       return;
+    }
+        pproc->enmType = kSubProcFreed;
+#endif
+
+        free(pproc);
+}
+
+
+/*
+ * Description:
+ *       Create a command line buffer to pass to CreateProcess
+ *
+ * Returns:  the buffer or NULL for failure
+ *      Shell case:  sh_name a:/full/path/to/script argv[1] argv[2] ...
+ *  Otherwise:   argv[0] argv[1] argv[2] ...
+ *
+ * Notes/Dependencies:
+ *   CreateProcess does not take an argv, so this command creates a
+ *   command line for the executable.
+ */
+
+static char *
+make_command_line( char *shell_name, char *full_exec_path, char **argv)
+{
+        int             argc = 0;
+        char**          argvi;
+        int*            enclose_in_quotes = NULL;
+        int*            enclose_in_quotes_i;
+        unsigned int    bytes_required = 0;
+        char*           command_line;
+        char*           command_line_i;
+        int  cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */
+        int have_sh = 0; /* HAVE_CYGWIN_SHELL */
+#undef HAVE_CYGWIN_SHELL /* bird: paranoia */
+#ifdef HAVE_CYGWIN_SHELL
+        have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
+        cygwin_mode = 1;
+#endif
+
+        if (shell_name && full_exec_path) {
+                bytes_required
+                  = strlen(shell_name) + 1 + strlen(full_exec_path);
+                /*
+                 * Skip argv[0] if any, when shell_name is given.
+                 * The special case of "-c" in full_exec_path means
+                 * argv[0] is not the shell name, but the command string
+                 * to pass to the shell.
+                 */
+                if (*argv && strcmp(full_exec_path, "-c")) argv++;
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*argv) bytes_required++;
+        }
+
+        argvi = argv;
+        while (*(argvi++)) argc++;
+
+        if (argc) {
+                enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
+
+                if (!enclose_in_quotes) {
+                        return NULL;
+                }
+        }
+
+        /* We have to make one pass through each argv[i] to see if we need
+         * to enclose it in ", so we might as well figure out how much
+         * memory we'll need on the same pass.
+         */
+
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+
+                /*
+                 * We have to enclose empty arguments in ".
+                 */
+                if (!(*p)) *enclose_in_quotes_i = 1;
+
+                while(*p) {
+                        switch (*p) {
+                        case '\"':
+                                /*
+                                 * We have to insert a backslash for each "
+                                 * and each \ that precedes the ".
+                                 */
+                                bytes_required += (backslash_count + 1);
+                                backslash_count = 0;
+                                break;
+
+#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
+                        case '\\':
+                                backslash_count++;
+                                break;
+#endif
+        /*
+         * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress
+         * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so
+         * that argv in always equals argv out. This was removed.  Say you have
+         * such a program named glob.exe.  You enter
+         * glob '*'
+         * at the sh command prompt.  Obviously the intent is to make glob do the
+         * wildcarding instead of sh.  If we set *enclose_in_quotes_i for '*' or '?',
+         * then the command line that glob would see would be
+         * glob "*"
+         * and the _setargv in SETARGV.OBJ would _not_ expand the *.
+         */
+                        case ' ':
+                        case '\t':
+                                *enclose_in_quotes_i = 1;
+                                /* fall through */
+
+                        default:
+                                backslash_count = 0;
+                                break;
+                        }
+
+                        /*
+                         * Add one for each character in argv[i].
+                         */
+                        bytes_required++;
+
+                        p++;
+                }
+
+                if (*enclose_in_quotes_i) {
+                        /*
+                         * Add one for each enclosing ",
+                         * and one for each \ that precedes the
+                         * closing ".
+                         */
+                        bytes_required += (backslash_count + 2);
+                }
+
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*(++argvi)) bytes_required++;
+                enclose_in_quotes_i++;
+        }
+
+        /*
+         * Add one for the terminating NULL.
+         */
+        bytes_required++;
+#ifdef KMK /* for the space before the final " in case we need it. */
+	bytes_required++;
+#endif
+
+        command_line = (char*) malloc(bytes_required);
+
+        if (!command_line) {
+                free(enclose_in_quotes);
+                return NULL;
+        }
+
+        command_line_i = command_line;
+
+        if (shell_name && full_exec_path) {
+                while(*shell_name) {
+                        *(command_line_i++) = *(shell_name++);
+                }
+
+                *(command_line_i++) = ' ';
+
+                while(*full_exec_path) {
+                        *(command_line_i++) = *(full_exec_path++);
+                }
+
+                if (*argv) {
+                        *(command_line_i++) = ' ';
+                }
+        }
+
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+
+                if (*enclose_in_quotes_i) {
+                        *(command_line_i++) = '\"';
+                }
+
+                while(*p) {
+                        if (*p == '\"') {
+                                if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */
+                                        /* instead of a \", cygwin likes "" */
+                                        *(command_line_i++) = '\"';
+                                } else {
+
+                                /*
+                                 * We have to insert a backslash for the "
+                                 * and each \ that precedes the ".
+                                 */
+                                backslash_count++;
+
+                                while(backslash_count) {
+                                        *(command_line_i++) = '\\';
+                                        backslash_count--;
+                                };
+                                }
+#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
+                        } else if (*p == '\\') {
+                                backslash_count++;
+                        } else {
+                                backslash_count = 0;
+#endif
+                        }
+
+                        /*
+                         * Copy the character.
+                         */
+                        *(command_line_i++) = *(p++);
+                }
+
+                if (*enclose_in_quotes_i) {
+#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
+                        /*
+                         * Add one \ for each \ that precedes the
+                         * closing ".
+                         */
+                        while(backslash_count--) {
+                                *(command_line_i++) = '\\';
+                        };
+#endif
+#ifdef KMK
+                        /*
+                         * ash it put off by echo "hello world" ending up as:
+                         *  G:/.../kmk_ash.exe -c "echo ""hello world"""
+                         * It wants a space before the last '"'.
+			 * (The 'test_shell' goals in Makefile.kmk tests this problem.)
+                         */
+                        if (command_line_i[-1] == '\"' /* && cygwin_mode && have_sh*/ && !argvi[1]) {
+                            *(command_line_i++) = ' ';
+                        }
+#endif
+
+                        *(command_line_i++) = '\"';
+                }
+
+                /*
+                 * Append an intervening space.
+                 */
+                if (*(++argvi)) {
+                        *(command_line_i++) = ' ';
+                }
+
+                enclose_in_quotes_i++;
+        }
+
+        /*
+         * Append the terminating NULL.
+         */
+        *command_line_i = '\0';
+
+        free(enclose_in_quotes);
+        return command_line;
+}
+
+/*
+ * Description: Given an argv and optional envp, launch the process
+ *              using the default stdin, stdout, and stderr handles.
+ *              Also, register process so that process_wait_for_any_private()
+ *              can be used via process_file_io(NULL) or
+ *              process_wait_for_any().
+ *
+ * Returns:
+ *
+ * Notes/Dependencies:
+ */
+HANDLE
+process_easy(
+        char **argv,
+        char **envp,
+        int outfd,
+        int errfd)
+{
+  HANDLE hIn = INVALID_HANDLE_VALUE;
+  HANDLE hOut = INVALID_HANDLE_VALUE;
+  HANDLE hErr = INVALID_HANDLE_VALUE;
+  HANDLE hProcess, tmpIn, tmpOut, tmpErr;
+  DWORD e;
+
+  if (proc_index >= MAXIMUM_WAIT_OBJECTS) {
+        DB (DB_JOBS, ("process_easy: All process slots used up\n"));
+        return INVALID_HANDLE_VALUE;
+  }
+#ifdef KMK /* We can effort here by lettering CreateProcess/kernel do the standard handle duplication. */
+ if (outfd != -1 || errfd != -1) {
+#endif
+  /* Standard handles returned by GetStdHandle can be NULL or
+     INVALID_HANDLE_VALUE if the parent process closed them.  If that
+     happens, we open the null device and pass its handle to
+     CreateProcess as the corresponding handle to inherit.  */
+  tmpIn = GetStdHandle(STD_INPUT_HANDLE);
+  if (DuplicateHandle(GetCurrentProcess(),
+                      tmpIn,
+                      GetCurrentProcess(),
+                      &hIn,
+                      0,
+                      TRUE,
+                      DUPLICATE_SAME_ACCESS) == FALSE) {
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpIn = CreateFile("NUL", GENERIC_READ,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpIn != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpIn,
+                             GetCurrentProcess(),
+                             &hIn,
+                             0,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpIn);
+    }
+    if (hIn == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(In) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
+  }
+  if (outfd >= 0)
+    tmpOut = (HANDLE)_get_osfhandle (outfd);
+  else
+    tmpOut = GetStdHandle (STD_OUTPUT_HANDLE);
+  if (DuplicateHandle(GetCurrentProcess(),
+                      tmpOut,
+                      GetCurrentProcess(),
+                      &hOut,
+                      0,
+                      TRUE,
+                      DUPLICATE_SAME_ACCESS) == FALSE) {
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpOut = CreateFile("NUL", GENERIC_WRITE,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpOut != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpOut,
+                             GetCurrentProcess(),
+                             &hOut,
+                             0,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpOut);
+    }
+    if (hOut == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(Out) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
+  }
+  if (errfd >= 0)
+    tmpErr = (HANDLE)_get_osfhandle (errfd);
+  else
+    tmpErr = GetStdHandle(STD_ERROR_HANDLE);
+  if (DuplicateHandle(GetCurrentProcess(),
+                      tmpErr,
+                      GetCurrentProcess(),
+                      &hErr,
+                      0,
+                      TRUE,
+                      DUPLICATE_SAME_ACCESS) == FALSE) {
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpErr = CreateFile("NUL", GENERIC_WRITE,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpErr != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpErr,
+                             GetCurrentProcess(),
+                             &hErr,
+                             0,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpErr);
+    }
+    if (hErr == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(Err) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
+  }
+#ifdef KMK /* saving effort */
+ }
+#endif
+
+  hProcess = process_init_fd(hIn, hOut, hErr);
+
+  if (process_begin(hProcess, argv, envp, argv[0], NULL)) {
+    fake_exits_pending++;
+    /* process_begin() failed: make a note of that.  */
+    if (!((sub_process*) hProcess)->last_err)
+      ((sub_process*) hProcess)->last_err = -1;
+#ifdef KMK
+    if (!((sub_process*) hProcess)->exit_code)
+#endif
+      ((sub_process*) hProcess)->exit_code = process_last_err(hProcess);
+
+    /* close up unused handles */
+    if (hIn != INVALID_HANDLE_VALUE)
+      CloseHandle(hIn);
+    if (hOut != INVALID_HANDLE_VALUE)
+      CloseHandle(hOut);
+    if (hErr != INVALID_HANDLE_VALUE)
+      CloseHandle(hErr);
+  }
+
+  process_register(hProcess);
+
+  return hProcess;
+}
diff --git a/src/kmk/w32/subproc/w32err.c b/src/kmk/w32/subproc/w32err.c
new file mode 100644
index 0000000..14eebed
--- /dev/null
+++ b/src/kmk/w32/subproc/w32err.c
@@ -0,0 +1,85 @@
+/* Error handling for Windows
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <stdlib.h>
+#include <windows.h>
+#include "makeint.h"
+#include "w32err.h"
+
+/*
+ * Description: the windows32 version of perror()
+ *
+ * Returns:  a pointer to a static error
+ *
+ * Notes/Dependencies:  I got this from
+ *      comp.os.ms-windows.programmer.win32
+ */
+const char *
+map_windows32_error_to_string (DWORD ercode) {
+/*
+ * We used to have an MSVC-specific '__declspec (thread)' qualifier
+ * here, with the following comment:
+ *
+ * __declspec (thread) necessary if you will use multiple threads on MSVC
+ *
+ * However, Make was never multithreaded on Windows (except when
+ * Ctrl-C is hit, in which case the main thread is stopped
+ * immediately, so it doesn't matter in this context).  The functions
+ * on sub_proc.c that started and stopped additional threads were
+ * never used, and are now #ifdef'ed away.  Until we need more than
+ * one thread, we have no problems with the following buffer being
+ * static.  (If and when we do need it to be in thread-local storage,
+ * the corresponding GCC qualifier is '__thread'.)
+ */
+    static char szMessageBuffer[128];
+        /* Fill message buffer with a default message in
+         * case FormatMessage fails
+         */
+    wsprintf (szMessageBuffer, "Error %ld\n", ercode);
+
+        /*
+         *  Special code for winsock error handling.
+         */
+        if (ercode > WSABASEERR) {
+#if 0
+                HMODULE hModule = GetModuleHandle("wsock32");
+                if (hModule != NULL) {
+                        FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+                                hModule,
+                                ercode,
+                                LANG_NEUTRAL,
+                                szMessageBuffer,
+                                sizeof(szMessageBuffer),
+                                NULL);
+                        FreeLibrary(hModule);
+                }
+#else
+                O (fatal, NILF, szMessageBuffer);
+#endif
+        } else {
+                /*
+                 *  Default system message handling
+                 */
+                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
+                        NULL,
+                        ercode,
+                        LANG_NEUTRAL,
+                        szMessageBuffer,
+                        sizeof(szMessageBuffer),
+                        NULL);
+        }
+    return szMessageBuffer;
+}
diff --git a/src/kmk/w32/tstFileInfo.c b/src/kmk/w32/tstFileInfo.c
new file mode 100644
index 0000000..94d47bb
--- /dev/null
+++ b/src/kmk/w32/tstFileInfo.c
@@ -0,0 +1,151 @@
+/* $Id: $ */
+/** @file
+ * Test program for some NtQueryInformationFile functionality.
+ */
+
+/*
+ * Copyright (c) 2007-2010 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ *
+ * This file is part of kBuild.
+ *
+ * kBuild is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * kBuild is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with kBuild.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+
+
+#include <stdio.h>
+#include <Windows.h>
+
+typedef enum _FILE_INFORMATION_CLASS {
+    FileDirectoryInformation       = 1,
+    FileFullDirectoryInformation,   // 2
+    FileBothDirectoryInformation,   // 3
+    FileBasicInformation,           // 4  wdm
+    FileStandardInformation,        // 5  wdm
+    FileInternalInformation,        // 6
+    FileEaInformation,              // 7
+    FileAccessInformation,          // 8
+    FileNameInformation,            // 9
+    FileRenameInformation,          // 10
+    FileLinkInformation,            // 11
+    FileNamesInformation,           // 12
+    FileDispositionInformation,     // 13
+    FilePositionInformation,        // 14 wdm
+    FileFullEaInformation,          // 15
+    FileModeInformation,            // 16
+    FileAlignmentInformation,       // 17
+    FileAllInformation,             // 18
+    FileAllocationInformation,      // 19
+    FileEndOfFileInformation,       // 20 wdm
+    FileAlternateNameInformation,   // 21
+    FileStreamInformation,          // 22
+    FilePipeInformation,            // 23
+    FilePipeLocalInformation,       // 24
+    FilePipeRemoteInformation,      // 25
+    FileMailslotQueryInformation,   // 26
+    FileMailslotSetInformation,     // 27
+    FileCompressionInformation,     // 28
+    FileObjectIdInformation,        // 29
+    FileCompletionInformation,      // 30
+    FileMoveClusterInformation,     // 31
+    FileQuotaInformation,           // 32
+    FileReparsePointInformation,    // 33
+    FileNetworkOpenInformation,     // 34
+    FileAttributeTagInformation,    // 35
+    FileTrackingInformation,        // 36
+    FileIdBothDirectoryInformation, // 37
+    FileIdFullDirectoryInformation, // 38
+    FileMaximumInformation
+} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
+
+typedef struct _FILE_NAME_INFORMATION
+{
+    ULONG FileNameLength;
+    WCHAR FileName[1];
+} FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION;
+
+typedef LONG NTSTATUS;
+
+typedef struct _IO_STATUS_BLOCK
+{
+    union
+    {
+        NTSTATUS Status;
+        PVOID Pointer;
+    };
+    ULONG_PTR Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+
+NTSYSAPI
+NTSTATUS
+NTAPI
+NtQueryInformationFile(HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID FileInformation,
+                       ULONG Length, FILE_INFORMATION_CLASS FileInformationClass);
+
+
+
+int main(int argc, char **argv)
+{
+    int rc = 0;
+    int i;
+
+    NTSTATUS (NTAPI *pfnNtQueryInformationFile)(HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID FileInformation,
+                                                ULONG Length, FILE_INFORMATION_CLASS FileInformationClass);
+
+    pfnNtQueryInformationFile = GetProcAddress(LoadLibrary("ntdll.dll"), "NtQueryInformationFile");
+
+    for (i = 1; i < argc; i++)
+    {
+        HANDLE hFile = CreateFile(argv[i],
+                                  GENERIC_READ,
+                                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                  NULL,
+                                  OPEN_EXISTING,
+                                  FILE_FLAG_BACKUP_SEMANTICS,
+                                  NULL);
+        if (hFile)
+        {
+            long rcNt;
+            char abBuf[4096];
+            IO_STATUS_BLOCK Ios;
+
+            memset(abBuf, 0, sizeof(abBuf));
+            memset(&Ios, 0, sizeof(Ios));
+            rcNt = pfnNtQueryInformationFile(hFile, &Ios, abBuf, sizeof(abBuf), FileNameInformation);
+            if (rcNt >= 0)
+            {
+                PFILE_NAME_INFORMATION pFileNameInfo = (PFILE_NAME_INFORMATION)abBuf;
+                printf("#%d: %s - rcNt=%#x - FileNameInformation:\n"
+                       "        FileName: %ls\n"
+                       "  FileNameLength: %lu\n",
+                       i, argv[i], rcNt,
+                       pFileNameInfo->FileName,
+                       pFileNameInfo->FileNameLength
+                       );
+            }
+            else
+                printf("#%d: %s - rcNt=%#x - FileNameInformation!\n", i, argv[i], rcNt);
+
+            CloseHandle(hFile);
+        }
+        else
+        {
+            printf("#%d: %s - open failed, last error %d\n", i, argv[i], GetLastError());
+            rc = 1;
+        }
+    }
+    return rc;
+}
+
diff --git a/src/kmk/w32/w32os.c b/src/kmk/w32/w32os.c
new file mode 100644
index 0000000..fd30661
--- /dev/null
+++ b/src/kmk/w32/w32os.c
@@ -0,0 +1,220 @@
+/* Windows32-based operating system interface for GNU Make.
+Copyright (C) 2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "makeint.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <windows.h>
+#include <process.h>
+#include <io.h>
+#include "pathstuff.h"
+#ifndef CONFIG_NEW_WIN_CHILDREN
+# include "sub_proc.h"
+#else
+# include "winchildren.h"
+#endif
+#include "w32err.h"
+#include "os.h"
+#include "debug.h"
+
+/* This section provides OS-specific functions to support the jobserver.  */
+
+static char jobserver_semaphore_name[MAX_PATH + 1];
+static HANDLE jobserver_semaphore = NULL;
+
+unsigned int
+jobserver_setup (int slots)
+{
+#ifndef CONFIG_NEW_WIN_CHILDREN
+  /* sub_proc.c cannot wait for more than MAXIMUM_WAIT_OBJECTS objects
+   * and one of them is the job-server semaphore object.  Limit the
+   * number of available job slots to (MAXIMUM_WAIT_OBJECTS - 1). */
+
+  if (slots >= MAXIMUM_WAIT_OBJECTS)
+    {
+      slots = MAXIMUM_WAIT_OBJECTS - 1;
+      DB (DB_JOBS, (_("Jobserver slots limited to %d\n"), slots));
+    }
+#endif
+
+  sprintf (jobserver_semaphore_name, "gmake_semaphore_%d", _getpid ());
+
+  jobserver_semaphore = CreateSemaphore (
+      NULL,                           /* Use default security descriptor */
+      slots,                          /* Initial count */
+      slots,                          /* Maximum count */
+      jobserver_semaphore_name);      /* Semaphore name */
+
+  if (jobserver_semaphore == NULL)
+    {
+      DWORD err = GetLastError ();
+      const char *estr = map_windows32_error_to_string (err);
+      ONS (fatal, NILF,
+           _("creating jobserver semaphore: (Error %ld: %s)"), err, estr);
+    }
+
+  return 1;
+}
+
+unsigned int
+jobserver_parse_auth (const char *auth)
+{
+  jobserver_semaphore = OpenSemaphore (
+      SEMAPHORE_ALL_ACCESS,   /* Semaphore access setting */
+      FALSE,                  /* Child processes DON'T inherit */
+      auth);                  /* Semaphore name */
+
+  if (jobserver_semaphore == NULL)
+    {
+      DWORD err = GetLastError ();
+      const char *estr = map_windows32_error_to_string (err);
+      fatal (NILF, strlen (auth) + INTSTR_LENGTH + strlen (estr),
+             _("internal error: unable to open jobserver semaphore '%s': (Error %ld: %s)"),
+             auth, err, estr);
+    }
+  DB (DB_JOBS, (_("Jobserver client (semaphore %s)\n"), auth));
+
+  return 1;
+}
+
+char *
+jobserver_get_auth ()
+{
+  return xstrdup (jobserver_semaphore_name);
+}
+
+unsigned int
+jobserver_enabled ()
+{
+  return jobserver_semaphore != NULL;
+}
+
+/* Close jobserver semaphore */
+void
+jobserver_clear ()
+{
+  if (jobserver_semaphore != NULL)
+    {
+      CloseHandle (jobserver_semaphore);
+      jobserver_semaphore = NULL;
+    }
+}
+
+void
+jobserver_release (int is_fatal)
+{
+  if (! ReleaseSemaphore (
+          jobserver_semaphore,    /* handle to semaphore */
+          1,                      /* increase count by one */
+          NULL))                  /* not interested in previous count */
+    {
+      if (is_fatal)
+        {
+          DWORD err = GetLastError ();
+          const char *estr = map_windows32_error_to_string (err);
+          ONS (fatal, NILF,
+               _("release jobserver semaphore: (Error %ld: %s)"), err, estr);
+        }
+      perror_with_name ("release_jobserver_semaphore", "");
+    }
+}
+
+unsigned int
+jobserver_acquire_all ()
+{
+  unsigned int tokens = 0;
+  while (1)
+    {
+      DWORD dwEvent = WaitForSingleObject (
+          jobserver_semaphore,    /* Handle to semaphore */
+          0);                     /* DON'T wait on semaphore */
+
+      if (dwEvent != WAIT_OBJECT_0)
+        return tokens;
+
+      ++tokens;
+    }
+}
+
+void
+jobserver_signal ()
+{
+}
+
+void jobserver_pre_child (int recursive)
+{
+}
+
+void jobserver_post_child (int recursive)
+{
+}
+
+void
+jobserver_pre_acquire ()
+{
+}
+
+/* Returns 1 if we got a token, or 0 if a child has completed.
+   The Windows implementation doesn't support load detection.  */
+unsigned int
+jobserver_acquire (int timeout)
+{
+#ifndef CONFIG_NEW_WIN_CHILDREN
+    HANDLE handles[MAXIMUM_WAIT_OBJECTS + 1]; /* bird: + 1 to prevent trashing the stack. */
+#else
+    HANDLE handles[2];
+#endif
+    DWORD dwHandleCount;
+    DWORD dwEvent;
+
+    /* Add jobserver semaphore to first slot. */
+    handles[0] = jobserver_semaphore;
+
+#ifndef CONFIG_NEW_WIN_CHILDREN
+    /* Build array of handles to wait for.  */
+    dwHandleCount = 1 + process_set_handles (&handles[1]);
+    dwEvent = WaitForMultipleObjects (
+        dwHandleCount,  /* number of objects in array */
+        handles,        /* array of objects */
+        FALSE,          /* wait for any object */
+        INFINITE);      /* wait until object is signalled */
+#else
+    /* Add the completed children event as the 2nd one. */
+    handles[1] = (HANDLE)MkWinChildGetCompleteEventHandle ();
+    if (handles[1] == NULL)
+      return 0;
+    dwHandleCount = 2;
+    dwEvent = WaitForMultipleObjectsEx (dwHandleCount,
+                                        handles,
+                                        FALSE /*bWaitAll*/,
+                                        256, /* INFINITE - paranoia, only wait 256 ms before checking again. */
+                                        TRUE /*bAlertable*/);
+#endif
+
+    if (dwEvent == WAIT_FAILED)
+      {
+        DWORD err = GetLastError ();
+        const char *estr = map_windows32_error_to_string (err);
+        ONS (fatal, NILF,
+             _("semaphore or child process wait: (Error %ld: %s)"),
+             err, estr);
+      }
+
+    /* WAIT_OBJECT_0 indicates that the semaphore was signalled.  */
+    return dwEvent == WAIT_OBJECT_0;
+}
diff --git a/src/kmk/w32/winchildren.c b/src/kmk/w32/winchildren.c
new file mode 100644
index 0000000..635fe99
--- /dev/null
+++ b/src/kmk/w32/winchildren.c
@@ -0,0 +1,3729 @@
+/* $Id: winchildren.c 3359 2020-06-05 16:17:17Z bird $ */
+/** @file
+ * Child process creation and management for kmk.
+ */
+
+/*
+ * Copyright (c) 2018 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ *
+ * This file is part of kBuild.
+ *
+ * kBuild is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * kBuild is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with kBuild.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+/* No GNU coding style here atm, convert if upstreamed. */
+
+/** @page pg_win_children   Windows child process creation and managment
+ *
+ * This new implementation aims at addressing the following:
+ *
+ *      1. Speed up process creation by doing the expensive CreateProcess call
+ *         in a worker thread.
+ *
+ *      2. No 64 process limit imposed by WaitForMultipleObjects.
+ *
+ *      3. Better distribute jobs among processor groups.
+ *
+ *      4. Offloading more expensive kmkbuiltin operations to worker threads,
+ *         making the main thread focus on managing child processes.
+ *
+ *      5. Output synchronization using reusable pipes.
+ *
+ *
+ * To be quite honest, the first item (CreateProcess expense) didn't occur to me
+ * at first and was more of a sideeffect discovered along the way.  A test
+ * rebuilding IPRT went from 4m52s to 3m19s on a 8 thread system.
+ *
+ * The 2nd and 3rd goals are related to newer build servers that have lots of
+ * CPU threads and various Windows NT (aka NT OS/2 at the time) design choices
+ * made in the late 1980ies.
+ *
+ * WaitForMultipleObjects does not support waiting for more than 64 objects,
+ * unlike poll and select.  This is just something everyone ends up having to
+ * work around in the end.
+ *
+ * Affinity masks are uintptr_t sized, so 64-bit hosts can only manage 64
+ * processors and 32-bit only 32.  Workaround was introduced with Windows 7
+ * (IIRC) and is called processor groups.  The CPU threads are grouped into 1 or
+ * more groups of up to 64 processors.  Processes are generally scheduled to a
+ * signle processor group at first, but threads may be changed to be scheduled
+ * on different groups.  This code will try distribute children evenly among the
+ * processor groups, using a very simple algorithm (see details in code).
+ *
+ *
+ * @section sec_win_children_av     Remarks on Microsoft Defender and other AV
+ *
+ * Part of the motivation for writing this code was horrible CPU utilization on
+ * a brand new AMD Threadripper 1950X system with lots of memory and SSDs,
+ * running 64-bit Windows 10 build 16299.
+ *
+ * Turns out Microsoft defender adds some overhead to CreateProcess
+ * and other stuff:
+ *     - Old make with CreateProcess on main thread:
+ *          - With runtime defender enabled: 14 min  6 seconds
+ *          - With runtime defender disabled: 4 min 49 seconds
+ *     - New make with CreateProcess on worker thread (this code):
+ *          - With runtime defender enabled:  6 min 29 seconds
+ *          - With runtime defender disabled: 4 min 36 seconds
+ *          - With runtime defender disabled out dir only: 5 min 59 seconds
+ *
+ * See also kWorker / kSubmit for more bickering about AV & disk encryption.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <Windows.h>
+#include <Winternl.h>
+
+#include "../makeint.h"
+#include "../job.h"
+#include "../filedef.h"
+#include "../debug.h"
+#include "../kmkbuiltin.h"
+#include "winchildren.h"
+
+#include <assert.h>
+#include <process.h>
+#include <intrin.h>
+
+#include "nt/nt_child_inject_standard_handles.h"
+#include "console.h"
+
+#ifndef KMK_BUILTIN_STANDALONE
+extern void kmk_cache_exec_image_w(const wchar_t *); /* imagecache.c */
+#endif
+
+/* Option values from main.c: */
+extern const char *win_job_object_mode;
+extern const char *win_job_object_name;
+extern int         win_job_object_no_kill;
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define MKWINCHILD_MAX_PATH     1024
+
+#define MKWINCHILD_DO_SET_PROCESSOR_GROUP
+
+/** Checks the UTF-16 environment variable pointed to is the PATH. */
+#define IS_PATH_ENV_VAR(a_cwcVar, a_pwszVar) \
+    (   (a_cwcVar) >= 5 \
+     &&  (a_pwszVar)[4] == L'=' \
+     && ((a_pwszVar)[0] == L'P' || (a_pwszVar)[0] == L'p') \
+     && ((a_pwszVar)[1] == L'A' || (a_pwszVar)[1] == L'a') \
+     && ((a_pwszVar)[2] == L'T' || (a_pwszVar)[2] == L't') \
+     && ((a_pwszVar)[3] == L'H' || (a_pwszVar)[3] == L'h') )
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/** Pointer to a childcare worker thread.   */
+typedef struct WINCHILDCAREWORKER *PWINCHILDCAREWORKER;
+/** Pointer to a windows child process. */
+typedef struct WINCHILD *PWINCHILD;
+
+
+/**
+ * Child process type.
+ */
+typedef enum WINCHILDTYPE
+{
+    WINCHILDTYPE_INVALID = 0,
+    /** Normal child process. */
+    WINCHILDTYPE_PROCESS,
+#ifdef KMK
+    /** kmkbuiltin command. */
+    WINCHILDTYPE_BUILT_IN,
+    /** kmkbuiltin_append result write out. */
+    WINCHILDTYPE_APPEND,
+    /** kSubmit job. */
+    WINCHILDTYPE_SUBMIT,
+    /** kmk_redirect job. */
+    WINCHILDTYPE_REDIRECT,
+#endif
+    /** End of valid child types. */
+    WINCHILDTYPE_END
+} WINCHILDTYPE;
+
+
+/**
+ * Windows child process.
+ */
+typedef struct WINCHILD
+{
+    /** Magic / eyecatcher (WINCHILD_MAGIC). */
+    ULONG                   uMagic;
+    /** Child type. */
+    WINCHILDTYPE            enmType;
+    /** Pointer to the next child process. */
+    PWINCHILD               pNext;
+    /** The pid for this child. */
+    pid_t                   pid;
+    /** The make child structure associated with this child. */
+    struct child           *pMkChild;
+
+    /** The process exit code. */
+    int                     iExitCode;
+    /** Kill signal, in case we or someone else killed it. */
+    int                     iSignal;
+    /** Set if core was dumped. */
+    int                     fCoreDumped;
+    /** Set if the a child process is a candidate for cl.exe where we supress
+     * annoying source name output. */
+    BOOL                    fProbableClExe;
+    /** The worker executing this child. */
+    PWINCHILDCAREWORKER     pWorker;
+
+    /** Type specific data. */
+    union
+    {
+        /** Data for WINCHILDTYPE_PROCESS.   */
+        struct
+        {
+            /** Argument vector (single allocation, strings following array). */
+            char          **papszArgs;
+            /** Length of the argument strings. */
+            size_t          cbArgsStrings;
+            /** Environment vector.  Only a copy if fEnvIsCopy is set. */
+            char          **papszEnv;
+            /** If we made a copy of the environment, this is the size of the
+             * strings and terminator string (not in array).  This is done to
+             * speed up conversion, since MultiByteToWideChar can handle '\0'. */
+            size_t          cbEnvStrings;
+            /** The make shell to use (copy). */
+            char           *pszShell;
+            /** Handle to use for standard out. */
+            HANDLE          hStdOut;
+            /** Handle to use for standard out. */
+            HANDLE          hStdErr;
+            /** Whether to close hStdOut after creating the process.  */
+            BOOL            fCloseStdOut;
+            /** Whether to close hStdErr after creating the process.  */
+            BOOL            fCloseStdErr;
+            /** Whether to catch output from the process. */
+            BOOL            fCatchOutput;
+
+            /** Child process handle. */
+            HANDLE          hProcess;
+        } Process;
+
+        /** Data for WINCHILDTYPE_BUILT_IN.   */
+        struct
+        {
+            /** The built-in command. */
+            PCKMKBUILTINENTRY pBuiltIn;
+            /** Number of arguments. */
+            int             cArgs;
+            /** Argument vector (single allocation, strings following array). */
+            char          **papszArgs;
+            /** Environment vector.  Only a copy if fEnvIsCopy is set. */
+            char          **papszEnv;
+        } BuiltIn;
+
+        /** Data for WINCHILDTYPE_APPEND.   */
+        struct
+        {
+            /** The filename. */
+            char           *pszFilename;
+            /** How much to append. */
+            size_t          cbAppend;
+            /** What to append. */
+            char           *pszAppend;
+            /** Whether to truncate the file. */
+            int             fTruncate;
+        } Append;
+
+        /** Data for WINCHILDTYPE_SUBMIT.   */
+        struct
+        {
+            /** The event we're to wait on (hooked up to a pipe) */
+            HANDLE          hEvent;
+            /** Parameter for the cleanup callback. */
+            void           *pvSubmitWorker;
+            /** Standard output catching pipe. Optional. */
+            PWINCCWPIPE     pStdOut;
+            /** Standard error catching pipe. Optional. */
+            PWINCCWPIPE     pStdErr;
+        } Submit;
+
+        /** Data for WINCHILDTYPE_REDIRECT.   */
+        struct
+        {
+            /** Child process handle. */
+            HANDLE          hProcess;
+        } Redirect;
+    } u;
+
+} WINCHILD;
+/** WINCHILD::uMagic value. */
+#define WINCHILD_MAGIC      0xbabebabeU
+
+
+/**
+ * Data for a windows childcare worker thread.
+ *
+ * We use one worker thread per child, reusing the threads when possible.
+ *
+ * This setup helps avoid the 64-bit handle with the WaitForMultipleObject API.
+ *
+ * It also helps using all CPUs on systems with more than one CPU group
+ * (typically systems with more than 64 CPU threads or/and multiple sockets, or
+ * special configs).
+ *
+ * This helps facilitates using pipes for collecting output child rather
+ * than temporary files.  Pipes doesn't involve NTFS and can easily be reused.
+ *
+ * Finally, kBuild specific, this allows running kmkbuiltin_xxxx commands in
+ * threads.
+ */
+typedef struct WINCHILDCAREWORKER
+{
+    /** Magic / eyecatcher (WINCHILDCAREWORKER_MAGIC). */
+    ULONG                   uMagic;
+    /** The worker index. */
+    unsigned int            idxWorker;
+    /** The processor group for this worker. */
+    unsigned int            iProcessorGroup;
+    /** The thread ID. */
+    unsigned int            tid;
+    /** The thread handle. */
+    HANDLE                  hThread;
+    /** The event the thread is idling on. */
+    HANDLE                  hEvtIdle;
+    /** The pipe catching standard output from a child. */
+    PWINCCWPIPE             pStdOut;
+    /** The pipe catching standard error from a child. */
+    PWINCCWPIPE             pStdErr;
+
+    /** Pointer to the current child. */
+    PWINCHILD volatile      pCurChild;
+    /** List of children pending execution on this worker.
+     * This is updated atomitically just like g_pTailCompletedChildren.  */
+    PWINCHILD volatile      pTailTodoChildren;
+    /** TRUE if idle, FALSE if not. */
+    long volatile           fIdle;
+} WINCHILDCAREWORKER;
+/** WINCHILD::uMagic value. */
+#define WINCHILDCAREWORKER_MAGIC    0xdad0dad0U
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Whether it's initialized or not. */
+static BOOL                 g_fInitialized = FALSE;
+/** Set when we're shutting down everything. */
+static BOOL volatile        g_fShutdown = FALSE;
+/** Event used to wait for children. */
+static HANDLE               g_hEvtWaitChildren = INVALID_HANDLE_VALUE;
+/** Number of childcare workers currently in g_papChildCareworkers. */
+static unsigned             g_cChildCareworkers = 0;
+/** Maximum number of childcare workers in g_papChildCareworkers. */
+static unsigned             g_cChildCareworkersMax = 0;
+/** Pointer to childcare workers. */
+static PWINCHILDCAREWORKER *g_papChildCareworkers = NULL;
+/** The processor group allocator state. */
+static MKWINCHILDCPUGROUPALLOCSTATE g_ProcessorGroupAllocator;
+/** Number of processor groups in the system.   */
+static unsigned             g_cProcessorGroups = 1;
+/** Array detailing how many active processors there are in each group. */
+static unsigned const      *g_pacProcessorsInGroup = &g_cProcessorGroups;
+/** Kernel32!GetActiveProcessorGroupCount */
+static WORD (WINAPI        *g_pfnGetActiveProcessorGroupCount)(VOID);
+/** Kernel32!GetActiveProcessorCount */
+static DWORD (WINAPI       *g_pfnGetActiveProcessorCount)(WORD);
+/** Kernel32!SetThreadGroupAffinity */
+static BOOL (WINAPI        *g_pfnSetThreadGroupAffinity)(HANDLE, CONST GROUP_AFFINITY *, GROUP_AFFINITY *);
+/** NTDLL!NtQueryInformationProcess */
+static NTSTATUS (NTAPI     *g_pfnNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
+/** Set if the windows host is 64-bit. */
+static BOOL                 g_f64BitHost = (K_ARCH_BITS == 64);
+/** Windows version info.
+ * @note Putting this before the volatile stuff, hoping to keep it in a
+ *       different cache line than the static bits above. */
+static OSVERSIONINFOA       g_VersionInfo = { sizeof(g_VersionInfo), 4, 0, 1381, VER_PLATFORM_WIN32_NT, {0} };
+
+/** Children that has been completed.
+ * This is updated atomically, pushing completed children in LIFO fashion
+ * (thus 'tail'), then hitting g_hEvtWaitChildren if head. */
+static PWINCHILD volatile   g_pTailCompletedChildren = NULL;
+
+/** Number of idle pending children.
+ * This is updated before g_hEvtWaitChildren is signalled. */
+static unsigned volatile    g_cPendingChildren = 0;
+
+/** Number of idle childcare worker threads. */
+static unsigned volatile    g_cIdleChildcareWorkers = 0;
+/** Index of the last idle child careworker (just a hint). */
+static unsigned volatile    g_idxLastChildcareWorker = 0;
+
+#ifdef WITH_RW_LOCK
+/** RW lock for serializing kmkbuiltin_redirect and CreateProcess. */
+static SRWLOCK              g_RWLock;
+#endif
+
+/** The job object for this make instance, if we created/opened one. */
+static HANDLE               g_hJob = NULL;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static void mkWinChildInitJobObjectAssociation(void);
+
+#if K_ARCH_BITS == 32 && !defined(_InterlockedCompareExchangePointer)
+/** _InterlockedCompareExchangePointer is missing? (VS2010) */
+K_INLINE void *_InterlockedCompareExchangePointer(void * volatile *ppvDst, void *pvNew, void *pvOld)
+{
+    return (void *)_InterlockedCompareExchange((long volatile *)ppvDst, (intptr_t)pvNew, (intptr_t)pvOld);
+}
+#endif
+
+
+/**
+ * Initializes the windows child module.
+ *
+ * @param   cJobSlots           The number of job slots.
+ */
+void MkWinChildInit(unsigned int cJobSlots)
+{
+    HMODULE hmod;
+
+    /*
+     * Figure out how many childcare workers first.
+     */
+    static unsigned int const s_cMaxWorkers = 4096;
+    unsigned cWorkers;
+    if (cJobSlots >= 1 && cJobSlots < s_cMaxWorkers)
+        cWorkers = cJobSlots;
+    else
+        cWorkers = s_cMaxWorkers;
+
+    /*
+     * Allocate the array and the child completed event object.
+     */
+    g_papChildCareworkers = (PWINCHILDCAREWORKER *)xcalloc(cWorkers * sizeof(g_papChildCareworkers[0]));
+    g_cChildCareworkersMax = cWorkers;
+
+    g_hEvtWaitChildren = CreateEvent(NULL, FALSE /*fManualReset*/, FALSE /*fInitialState*/, NULL /*pszName*/);
+    if (!g_hEvtWaitChildren)
+        fatal(NILF, INTSTR_LENGTH, _("MkWinChildInit: CreateEvent failed: %u"), GetLastError());
+
+    /*
+     * NTDLL imports that we need.
+     */
+    hmod = GetModuleHandleA("NTDLL.DLL");
+    *(FARPROC *)&g_pfnNtQueryInformationProcess = GetProcAddress(hmod, "NtQueryInformationProcess");
+    if (!g_pfnNtQueryInformationProcess)
+        fatal(NILF, 0, _("MkWinChildInit: NtQueryInformationProcess not found"));
+
+#if K_ARCH_BITS == 32
+    /*
+     * Initialize g_f64BitHost.
+     */
+    if (!IsWow64Process(GetCurrentProcess(), &g_f64BitHost))
+        fatal(NILF, INTSTR_LENGTH, _("MkWinChildInit: IsWow64Process failed: %u"), GetLastError());
+#elif K_ARCH_BITS == 64
+    assert(g_f64BitHost);
+#else
+# error "K_ARCH_BITS is bad/missing"
+#endif
+
+    /*
+     * Figure out how many processor groups there are.
+     * For that we need to first figure the windows version.
+     */
+    if (!GetVersionExA(&g_VersionInfo))
+    {
+        DWORD uRawVer = GetVersion();
+        g_VersionInfo.dwMajorVersion = uRawVer & 0xff;
+        g_VersionInfo.dwMinorVersion = (uRawVer >>  8) &   0xff;
+        g_VersionInfo.dwBuildNumber  = (uRawVer >> 16) & 0x7fff;
+    }
+    if (g_VersionInfo.dwMajorVersion >= 6)
+    {
+        hmod = GetModuleHandleA("KERNEL32.DLL");
+        *(FARPROC *)&g_pfnGetActiveProcessorGroupCount = GetProcAddress(hmod, "GetActiveProcessorGroupCount");
+        *(FARPROC *)&g_pfnGetActiveProcessorCount      = GetProcAddress(hmod, "GetActiveProcessorCount");
+        *(FARPROC *)&g_pfnSetThreadGroupAffinity       = GetProcAddress(hmod, "SetThreadGroupAffinity");
+        if (   g_pfnSetThreadGroupAffinity
+            && g_pfnGetActiveProcessorCount
+            && g_pfnGetActiveProcessorGroupCount)
+        {
+            unsigned int *pacProcessorsInGroup;
+            unsigned      iGroup;
+            g_cProcessorGroups = g_pfnGetActiveProcessorGroupCount();
+            if (g_cProcessorGroups == 0)
+                g_cProcessorGroups = 1;
+
+            pacProcessorsInGroup = (unsigned int *)xmalloc(sizeof(g_pacProcessorsInGroup[0]) * g_cProcessorGroups);
+            g_pacProcessorsInGroup = pacProcessorsInGroup;
+            for (iGroup = 0; iGroup < g_cProcessorGroups; iGroup++)
+                pacProcessorsInGroup[iGroup] = g_pfnGetActiveProcessorCount(iGroup);
+
+            MkWinChildInitCpuGroupAllocator(&g_ProcessorGroupAllocator);
+        }
+        else
+        {
+            g_pfnSetThreadGroupAffinity       = NULL;
+            g_pfnGetActiveProcessorCount      = NULL;
+            g_pfnGetActiveProcessorGroupCount = NULL;
+        }
+    }
+
+#ifdef WITH_RW_LOCK
+    /*
+     * For serializing with standard file handle manipulation (kmkbuiltin_redirect).
+     */
+    InitializeSRWLock(&g_RWLock);
+#endif
+
+    /*
+     * Associate with a job object.
+     */
+    mkWinChildInitJobObjectAssociation();
+
+    /*
+     * This is dead code that was thought to fix a problem observed doing
+     * `tcc.exe /c "kmk |& tee bld.log"` and leading to a crash in cl.exe
+     * when spawned with fInheritHandles = FALSE, see hStdErr=NULL in the
+     * child.  However, it turns out this was probably caused by not clearing
+     * the CRT file descriptor and handle table in the startup info.
+     * Leaving the code here in case it comes in handy after all.
+     */
+#if 0
+    {
+        struct
+        {
+            DWORD  uStdHandle;
+            HANDLE hHandle;
+        } aHandles[3] = { { STD_INPUT_HANDLE, NULL }, { STD_OUTPUT_HANDLE, NULL }, { STD_ERROR_HANDLE, NULL } };
+        int i;
+
+        for (i = 0; i < 3; i++)
+            aHandles[i].hHandle = GetStdHandle(aHandles[i].uStdHandle);
+
+        for (i = 0; i < 3; i++)
+            if (   aHandles[i].hHandle == NULL
+                || aHandles[i].hHandle == INVALID_HANDLE_VALUE)
+            {
+                int fd = open("nul", _O_RDWR);
+                if (fd >= 0)
+                {
+                    if (_dup2(fd, i) >= 0)
+                    {
+                        assert((HANDLE)_get_osfhandle(i) != aHandles[i].hHandle);
+                        assert((HANDLE)_get_osfhandle(i) == GetStdHandle(aHandles[i].uStdHandle));
+                    }
+                    else
+                        ONNNS(fatal, NILF, "_dup2(%d('nul'), %d) failed: %u (%s)", fd, i, errno, strerror(errno));
+                    if (fd != i)
+                        close(fd);
+                }
+                else
+                    ONNS(fatal, NILF, "open(nul,RW) failed: %u (%s)", i, errno, strerror(errno));
+            }
+            else
+            {
+                int j;
+                for (j = i + 1; j < 3; j++)
+                    if (aHandles[j].hHandle == aHandles[i].hHandle)
+                    {
+                        int fd = _dup(j);
+                        if (fd >= 0)
+                        {
+                            if (_dup2(fd, j) >= 0)
+                            {
+                                aHandles[j].hHandle = (HANDLE)_get_osfhandle(j);
+                                assert(aHandles[j].hHandle != aHandles[i].hHandle);
+                                assert(aHandles[j].hHandle == GetStdHandle(aHandles[j].uStdHandle));
+                            }
+                            else
+                                ONNNS(fatal, NILF, "_dup2(%d, %d) failed: %u (%s)", fd, j, errno, strerror(errno));
+                            if (fd != j)
+                                close(fd);
+                        }
+                        else
+                            ONNS(fatal, NILF, "_dup(%d) failed: %u (%s)", j, errno, strerror(errno));
+                    }
+            }
+    }
+#endif
+}
+
+/**
+ * Create or open a job object for this make instance and its children.
+ *
+ * Depending on the --job-object=mode value, we typically create/open a job
+ * object here if we're the root make instance.  The job object is then
+ * typically configured to kill all remaining processes when the root make
+ * terminates, so that there aren't any stuck processes around messing up
+ * subsequent builds.  This is very handy on build servers.
+ *
+ * If we're it no-kill mode, the job object is pretty pointless for manual
+ * cleanup as the job object becomes invisible (or something) when the last
+ * handle to it closes, i.e. g_hJob.  On windows 8 and later it looks
+ * like any orphaned children are immediately assigned to the parent job
+ * object.  Too bad for kmk_kill and such.
+ *
+ * win_job_object_mode values: login, root, each, none
+ */
+static void mkWinChildInitJobObjectAssociation(void)
+{
+    BOOL        fCreate   = TRUE;
+    char        szJobName[128];
+    const char *pszJobName = win_job_object_name;
+
+    /* Skip if disabled. */
+    if (strcmp(win_job_object_mode, "none") == 0)
+        return;
+
+    /* Skip if not root make instance, unless we're having one job object
+       per make instance. */
+    if (   makelevel != 0
+        && strcmp(win_job_object_mode, "each") != 0)
+        return;
+
+    /* Format the the default job object name if --job-object-name
+       wasn't given. */
+    if (!pszJobName || *pszJobName == '\0')
+    {
+        pszJobName = szJobName;
+        if (strcmp(win_job_object_mode, "login") == 0)
+        {
+            /* Use the AuthenticationId like mspdbsrv.exe does. */
+            HANDLE hToken;
+            if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
+            {
+                TOKEN_STATISTICS TokenStats;
+                DWORD            cbRet = 0;
+                memset(&TokenStats, 0, sizeof(TokenStats));
+                if (GetTokenInformation(hToken, TokenStatistics, &TokenStats, sizeof(TokenStats), &cbRet))
+                    snprintf(szJobName, sizeof(szJobName), "kmk-job-obj-login-%08x.%08x",
+                             (unsigned)TokenStats.AuthenticationId.HighPart, (unsigned)TokenStats.AuthenticationId.LowPart);
+                else
+                {
+                    ONN(message, 0, _("GetTokenInformation failed: %u (cbRet=%u)"), GetLastError(), cbRet);
+                    return;
+                }
+                CloseHandle(hToken);
+            }
+            else
+            {
+                ON(message, 0, _("OpenProcessToken failed: %u"), GetLastError());
+                return;
+            }
+        }
+        else
+        {
+            SYSTEMTIME Now = {0};
+            GetSystemTime(&Now);
+            snprintf(szJobName, sizeof(szJobName), "kmk-job-obj-%04u-%02u-%02uT%02u-%02u-%02uZ%u",
+                     Now.wYear, Now.wMonth, Now.wDay, Now.wHour, Now.wMinute, Now.wSecond, getpid());
+        }
+    }
+
+    /* In login mode and when given a job object name, we try open it first. */
+    if (   win_job_object_name
+        || strcmp(win_job_object_mode, "login") == 0)
+    {
+        g_hJob = OpenJobObjectA(JOB_OBJECT_ASSIGN_PROCESS, win_job_object_no_kill /*bInheritHandle*/, pszJobName);
+        if (g_hJob)
+            fCreate = FALSE;
+        else
+        {
+            DWORD dwErr = GetLastError();
+            if (dwErr != ERROR_PATH_NOT_FOUND && dwErr != ERROR_FILE_NOT_FOUND)
+            {
+                OSN(message, 0, _("OpenJobObjectA(,,%s) failed: %u"), pszJobName, GetLastError());
+                return;
+            }
+        }
+    }
+
+    if (fCreate)
+    {
+        SECURITY_ATTRIBUTES SecAttr = { sizeof(SecAttr), NULL, TRUE /*bInheritHandle*/ };
+        g_hJob = CreateJobObjectA(win_job_object_no_kill ? &SecAttr : NULL, pszJobName);
+        if (g_hJob)
+        {
+            /* We need to set the BREAKAWAY_OK flag, as we don't want make CreateProcess
+               fail if someone tries to break way.  Also set KILL_ON_JOB_CLOSE unless
+               --job-object-no-kill is given. */
+            JOBOBJECT_EXTENDED_LIMIT_INFORMATION Info;
+            DWORD cbActual = 0;
+            memset(&Info, 0, sizeof(Info));
+            if (QueryInformationJobObject(g_hJob, JobObjectExtendedLimitInformation, &Info, sizeof(Info), &cbActual))
+            {
+                Info.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_BREAKAWAY_OK;
+                if (!win_job_object_no_kill)
+                    Info.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+                else
+                    Info.BasicLimitInformation.LimitFlags &= ~JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+                if (!SetInformationJobObject(g_hJob, JobObjectExtendedLimitInformation, &Info, sizeof(Info)))
+                    OSSN(message, 0, _("SetInformationJobObject(%s,JobObjectExtendedLimitInformation,{%s},) failed: %u"),
+                         pszJobName, win_job_object_mode, GetLastError());
+            }
+            else
+                OSN(message, 0, _("QueryInformationJobObject(%s,JobObjectExtendedLimitInformation,,,) failed: %u"),
+                    pszJobName, GetLastError());
+        }
+        else
+        {
+            OSN(message, 0, _("CreateJobObjectA(NULL,%s) failed: %u"), pszJobName, GetLastError());
+            return;
+        }
+    }
+
+    /* Make it our job object. */
+    if (!(AssignProcessToJobObject(g_hJob, GetCurrentProcess())))
+        OSN(message, 0, _("AssignProcessToJobObject(%s, me) failed: %u"), pszJobName, GetLastError());
+}
+
+/**
+ * Used by mkWinChildcareWorkerThread() and MkWinChildWait() to get the head
+ * child from a lifo (g_pTailCompletedChildren, pTailTodoChildren).
+ *
+ * @returns Head child.
+ * @param   ppTail          Pointer to the child variable.
+ * @param   pChild          Tail child.
+ */
+static PWINCHILD mkWinChildDequeFromLifo(PWINCHILD volatile *ppTail, PWINCHILD pChild)
+{
+    if (pChild->pNext)
+    {
+        PWINCHILD pPrev;
+        do
+        {
+            pPrev = pChild;
+            pChild = pChild->pNext;
+        } while (pChild->pNext);
+        pPrev->pNext = NULL;
+    }
+    else
+    {
+        PWINCHILD const pWantedChild = pChild;
+        pChild = _InterlockedCompareExchangePointer(ppTail, NULL, pWantedChild);
+        if (pChild != pWantedChild)
+        {
+            PWINCHILD pPrev;
+            do
+            {
+                pPrev = pChild;
+                pChild = pChild->pNext;
+            } while (pChild->pNext);
+            pPrev->pNext = NULL;
+            assert(pChild == pWantedChild);
+        }
+    }
+    return pChild;
+}
+
+/**
+ * Output error message while running on a worker thread.
+ *
+ * @returns -1
+ * @param   pWorker             The calling worker.  Mainly for getting the
+ *                              current child and its stderr output unit.  Pass
+ *                              NULL if the output should go thru the child
+ *                              stderr buffering.
+ * @param   iType               The error type:
+ *                                  - 0: more of a info directly to stdout,
+ *                                  - 1: child related error,
+ *                                  - 2: child related error for immedate release.
+ * @param   pszFormat           The message format string.
+ * @param   ...                 Argument for the message.
+ */
+static int MkWinChildError(PWINCHILDCAREWORKER pWorker, int iType, const char *pszFormat, ...)
+{
+    /*
+     * Format the message into stack buffer.
+     */
+    char        szMsg[4096];
+    int         cchMsg;
+    int         cchPrefix;
+    va_list     va;
+
+    /* Compose the prefix, being paranoid about it not exceeding the buffer in any way. */
+    const char *pszInfix = iType == 0 ? "info: " : "error: ";
+    const char *pszProgram = program;
+    if (strlen(pszProgram) > 80)
+    {
+#ifdef KMK
+        pszProgram = "kmk";
+#else
+        pszProgram = "gnumake";
+#endif
+    }
+    if (makelevel == 0)
+        cchPrefix = snprintf(szMsg, sizeof(szMsg) / 2, "%s: %s", pszProgram, pszInfix);
+    else
+        cchPrefix = snprintf(szMsg, sizeof(szMsg) / 2, "%s[%u]: %s", pszProgram, makelevel, pszInfix);
+    assert(cchPrefix < sizeof(szMsg) / 2 && cchPrefix > 0);
+
+    /* Format the user specified message. */
+    va_start(va, pszFormat);
+    cchMsg = vsnprintf(&szMsg[cchPrefix], sizeof(szMsg) - 2 - cchPrefix, pszFormat, va);
+    va_end(va);
+    szMsg[sizeof(szMsg) - 2] = '\0';
+    cchMsg = strlen(szMsg);
+
+    /* Make sure there's a newline at the end of it (we reserved space for that). */
+    if (cchMsg <= 0 || szMsg[cchMsg - 1] != '\n')
+    {
+        szMsg[cchMsg++] = '\n';
+        szMsg[cchMsg]   = '\0';
+    }
+
+#ifdef CONFIG_WITH_OUTPUT_IN_MEMORY
+    /*
+     * Try use the stderr of the current child of the worker.
+     */
+    if (   iType != 0
+        && iType != 3
+        && pWorker)
+    {
+        PWINCHILD pChild = pWorker->pCurChild;
+        if (pChild)
+        {
+            struct child *pMkChild = pChild->pMkChild;
+            if (pMkChild)
+            {
+                output_write_text(&pMkChild->output, 1 /*is_err*/, szMsg, cchMsg);
+                return -1;
+            }
+        }
+    }
+#endif
+
+    /*
+     * Fallback to writing directly to stderr.
+     */
+    maybe_con_fwrite(szMsg, cchMsg, 1, iType == 0 ? stdout : stderr);
+    return -1;
+}
+
+/**
+ * Duplicates the given UTF-16 string.
+ *
+ * @returns 0
+ * @param   pwszSrc             The UTF-16 string to duplicate.
+ * @param   cwcSrc              Length, may include the terminator.
+ * @param   ppwszDst            Where to return the duplicate.
+ */
+static int mkWinChildDuplicateUtf16String(const WCHAR *pwszSrc, size_t cwcSrc, WCHAR **ppwszDst)
+{
+    size_t cb = sizeof(WCHAR) * cwcSrc;
+    if (cwcSrc > 0 && pwszSrc[cwcSrc - 1] == L'\0')
+        *ppwszDst = (WCHAR *)memcpy(xmalloc(cb), pwszSrc, cb);
+    else
+    {
+        WCHAR *pwszDst = (WCHAR *)xmalloc(cb + sizeof(WCHAR));
+        memcpy(pwszDst, pwszSrc, cb);
+        pwszDst[cwcSrc] = L'\0';
+        *ppwszDst = pwszDst;
+    }
+    return 0;
+}
+
+
+/**
+ * Used to flush data we're read but not yet written at the termination of a
+ * process.
+ *
+ * @param   pChild          The child.
+ * @param   pPipe           The pipe.
+ */
+static void mkWinChildcareWorkerFlushUnwritten(PWINCHILD pChild, PWINCCWPIPE pPipe)
+{
+    DWORD cbUnwritten = pPipe->offPendingRead - pPipe->cbWritten;
+    assert(pPipe->cbWritten      <= pPipe->cbBuffer - 16);
+    assert(pPipe->offPendingRead <= pPipe->cbBuffer - 16);
+    if (cbUnwritten)
+    {
+#ifdef CONFIG_WITH_OUTPUT_IN_MEMORY
+        if (pChild && pChild->pMkChild)
+        {
+            output_write_bin(&pChild->pMkChild->output, pPipe->iWhich == 2, &pPipe->pbBuffer[pPipe->cbWritten], cbUnwritten);
+            pPipe->cbWritten += cbUnwritten;
+        }
+        else
+#endif
+        {
+            DWORD cbWritten = 0;
+            if (WriteFile(GetStdHandle(pPipe->iWhich == 1 ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE),
+                          &pPipe->pbBuffer[pPipe->cbWritten], cbUnwritten, &cbWritten, NULL))
+                pPipe->cbWritten += cbWritten <= cbUnwritten ? cbWritten : cbUnwritten; /* paranoia */
+        }
+        pPipe->fHaveWrittenOut = TRUE;
+    }
+}
+
+/**
+ * This logic mirrors kwSandboxConsoleFlushAll.
+ *
+ * @returns TRUE if it looks like a CL.EXE source line, otherwise FALSE.
+ * @param   pPipe               The pipe.
+ * @param   offStart            The start of the output in the pipe buffer.
+ * @param   offEnd              The end of the output in the pipe buffer.
+ */
+static BOOL mkWinChildcareWorkerIsClExeSourceLine(PWINCCWPIPE pPipe, DWORD offStart, DWORD offEnd)
+{
+    if (offEnd < offStart + 2)
+        return FALSE;
+    if (offEnd - offStart > 80)
+        return FALSE;
+
+    if (   pPipe->pbBuffer[offEnd - 2] != '\r'
+        || pPipe->pbBuffer[offEnd - 1] != '\n')
+        return FALSE;
+
+    offEnd -= 2;
+    while (offEnd-- > offStart)
+    {
+        char ch = pPipe->pbBuffer[offEnd];
+        if (isalnum(ch) || ch == '.' || ch == ' ' || ch == '_' || ch == '-')
+        { /* likely */ }
+        else
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+/**
+ * Adds output to the given standard output for the child.
+ *
+ * There is no pending read when this function is called, so we're free to
+ * reshuffle the buffer if desirable.
+ *
+ * @param   pChild          The child. Optional (kSubmit).
+ * @param   iWhich          Which standard descriptor number.
+ * @param   cbNewData       How much more output was caught.
+ */
+static void mkWinChildcareWorkerCaughtMoreOutput(PWINCHILD pChild, PWINCCWPIPE pPipe, DWORD cbNewData)
+{
+    DWORD offStart = pPipe->cbWritten;
+    assert(offStart <= pPipe->offPendingRead);
+    assert(offStart <= pPipe->cbBuffer - 16);
+    assert(pPipe->offPendingRead <= pPipe->cbBuffer - 16);
+    if (cbNewData > 0)
+    {
+        DWORD offRest;
+
+        /* Move offPendingRead ahead by cbRead. */
+        pPipe->offPendingRead += cbNewData;
+        assert(pPipe->offPendingRead <= pPipe->cbBuffer);
+        if (pPipe->offPendingRead > pPipe->cbBuffer)
+            pPipe->offPendingRead = pPipe->cbBuffer;
+
+        /* Locate the last newline in the buffer. */
+        offRest = pPipe->offPendingRead;
+        while (offRest > offStart && pPipe->pbBuffer[offRest - 1] != '\n')
+            offRest--;
+
+        /* If none were found and we've less than 16 bytes left in the buffer, try
+           find a word boundrary to flush on instead. */
+        if (   offRest <= offStart
+            && pPipe->cbBuffer - pPipe->offPendingRead + offStart < 16)
+        {
+            offRest = pPipe->offPendingRead;
+            while (   offRest > offStart
+                   && isalnum(pPipe->pbBuffer[offRest - 1]))
+                offRest--;
+            if (offRest == offStart)
+                offRest = pPipe->offPendingRead;
+        }
+        /* If this is a potential CL.EXE process, we will keep the source
+           filename unflushed and maybe discard it at the end. */
+        else if (   pChild
+                 && pChild->fProbableClExe
+                 && pPipe->iWhich == 1
+                 && offRest == pPipe->offPendingRead
+                 && mkWinChildcareWorkerIsClExeSourceLine(pPipe, offStart, offRest))
+            offRest = offStart;
+
+        if (offRest > offStart)
+        {
+            /* Write out offStart..offRest. */
+            DWORD cbToWrite = offRest - offStart;
+#ifdef CONFIG_WITH_OUTPUT_IN_MEMORY
+            if (pChild && pChild->pMkChild)
+            {
+                output_write_bin(&pChild->pMkChild->output, pPipe->iWhich == 2, &pPipe->pbBuffer[offStart], cbToWrite);
+                offStart += cbToWrite;
+                pPipe->cbWritten = offStart;
+            }
+            else
+#endif
+            {
+                DWORD cbWritten = 0;
+                if (WriteFile(GetStdHandle(pPipe->iWhich == 1 ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE),
+                              &pPipe->pbBuffer[offStart], cbToWrite, &cbWritten, NULL))
+                {
+                    offStart += cbWritten <= cbToWrite ? cbWritten : cbToWrite; /* paranoia */
+                    pPipe->cbWritten = offStart;
+                }
+            }
+            pPipe->fHaveWrittenOut = TRUE;
+        }
+    }
+
+    /* Shuffle the data to the front of the buffer.  */
+    if (offStart > 0)
+    {
+        DWORD cbUnwritten = pPipe->offPendingRead - offStart;
+        if (cbUnwritten > 0)
+            memmove(pPipe->pbBuffer, &pPipe->pbBuffer[offStart], cbUnwritten);
+        pPipe->offPendingRead -= pPipe->cbWritten;
+        pPipe->cbWritten       = 0;
+    }
+}
+
+/**
+ * Catches output from the given pipe.
+ *
+ * @param   pChild          The child. Optional (kSubmit).
+ * @param   pPipe           The pipe.
+ * @param   fDraining       Set if we're draining the pipe after the process
+ *                          terminated.
+ */
+static void mkWinChildcareWorkerCatchOutput(PWINCHILD pChild, PWINCCWPIPE pPipe, BOOL fDraining)
+{
+    /*
+     * Deal with already pending read.
+     */
+    if (pPipe->fReadPending)
+    {
+        DWORD cbRead = 0;
+        if (GetOverlappedResult(pPipe->hPipeMine, &pPipe->Overlapped, &cbRead, !fDraining))
+        {
+            mkWinChildcareWorkerCaughtMoreOutput(pChild, pPipe, cbRead);
+            pPipe->fReadPending = FALSE;
+        }
+        else if (fDraining && GetLastError() == ERROR_IO_INCOMPLETE)
+            return;
+        else
+        {
+            MkWinChildError(pChild ? pChild->pWorker : NULL, 2, "GetOverlappedResult failed: %u\n", GetLastError());
+            pPipe->fReadPending = FALSE;
+            if (fDraining)
+                return;
+        }
+    }
+
+    /*
+     * Read data till one becomes pending.
+     */
+    for (;;)
+    {
+        DWORD cbRead;
+
+        memset(&pPipe->Overlapped, 0, sizeof(pPipe->Overlapped));
+        pPipe->Overlapped.hEvent = pPipe->hEvent;
+        ResetEvent(pPipe->hEvent);
+
+        assert(pPipe->offPendingRead < pPipe->cbBuffer);
+        SetLastError(0);
+        cbRead = 0;
+        if (!ReadFile(pPipe->hPipeMine, &pPipe->pbBuffer[pPipe->offPendingRead],
+                      pPipe->cbBuffer - pPipe->offPendingRead, &cbRead, &pPipe->Overlapped))
+        {
+            DWORD dwErr = GetLastError();
+            if (dwErr == ERROR_IO_PENDING)
+                pPipe->fReadPending = TRUE;
+            else
+                MkWinChildError(pChild ? pChild->pWorker : NULL, 2,
+                                "ReadFile failed on standard %s: %u\n",
+                                pPipe->iWhich == 1 ? "output" : "error",  GetLastError());
+            return;
+        }
+
+        mkWinChildcareWorkerCaughtMoreOutput(pChild, pPipe, cbRead);
+    }
+}
+
+/**
+ * Makes sure the output pipes are drained and pushed to output.
+ *
+ * @param   pChild              The child. Optional (kSubmit).
+ * @param   pStdOut             The standard output pipe structure.
+ * @param   pStdErr             The standard error pipe structure.
+ */
+void MkWinChildcareWorkerDrainPipes(PWINCHILD pChild, PWINCCWPIPE pStdOut, PWINCCWPIPE pStdErr)
+{
+    mkWinChildcareWorkerCatchOutput(pChild, pStdOut, TRUE /*fDraining*/);
+    mkWinChildcareWorkerCatchOutput(pChild, pStdErr, TRUE /*fDraining*/);
+
+    /* Drop lone 'source.c' line from CL.exe, but only if no other output at all. */
+    if (   pChild
+        && pChild->fProbableClExe
+        && !pStdOut->fHaveWrittenOut
+        && !pStdErr->fHaveWrittenOut
+        && pStdErr->cbWritten == pStdErr->offPendingRead
+        && pStdOut->cbWritten < pStdOut->offPendingRead
+        && mkWinChildcareWorkerIsClExeSourceLine(pStdOut, pStdOut->cbWritten, pStdOut->offPendingRead))
+    {
+        if (!pStdOut->fReadPending)
+            pStdOut->cbWritten = pStdOut->offPendingRead = 0;
+        else
+            pStdOut->cbWritten = pStdOut->offPendingRead;
+    }
+    else
+    {
+        mkWinChildcareWorkerFlushUnwritten(pChild, pStdOut);
+        mkWinChildcareWorkerFlushUnwritten(pChild, pStdErr);
+    }
+}
+
+/**
+ * Commmon worker for waiting on a child process and retrieving the exit code.
+ *
+ * @returns Child exit code.
+ * @param   pWorker             The worker.
+ * @param   pChild              The child.
+ * @param   hProcess            The process handle.
+ * @param   pwszJob             The job name.
+ * @param   fCatchOutput        Set if we need to work the output pipes
+ *                              associated with the worker.
+ */
+static int mkWinChildcareWorkerWaitForProcess(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild, HANDLE hProcess,
+                                              WCHAR const *pwszJob, BOOL fCatchOutput)
+{
+    DWORD const msStart = GetTickCount();
+    DWORD       msNextMsg = msStart + 15000;
+
+    /* Reset the written indicators on the pipes before we start loop. */
+    pWorker->pStdOut->fHaveWrittenOut = FALSE;
+    pWorker->pStdErr->fHaveWrittenOut = FALSE;
+
+    for (;;)
+    {
+        /*
+         * Do the waiting and output catching.
+         */
+        DWORD dwStatus;
+        if (!fCatchOutput)
+            dwStatus = WaitForSingleObject(hProcess, 15001 /*ms*/);
+        else
+        {
+            HANDLE ahHandles[3] = { hProcess, pWorker->pStdOut->hEvent, pWorker->pStdErr->hEvent };
+            dwStatus = WaitForMultipleObjects(3, ahHandles, FALSE /*fWaitAll*/, 1000 /*ms*/);
+            if (dwStatus == WAIT_OBJECT_0 + 1)
+                mkWinChildcareWorkerCatchOutput(pChild, pWorker->pStdOut, FALSE /*fDraining*/);
+            else if (dwStatus == WAIT_OBJECT_0 + 2)
+                mkWinChildcareWorkerCatchOutput(pChild, pWorker->pStdErr, FALSE /*fDraining*/);
+        }
+        assert(dwStatus != WAIT_FAILED);
+
+        /*
+         * Get the exit code and return if the process was signalled as done.
+         */
+        if (dwStatus == WAIT_OBJECT_0)
+        {
+            DWORD dwExitCode = -42;
+            if (GetExitCodeProcess(hProcess, &dwExitCode))
+            {
+                pChild->iExitCode = (int)dwExitCode;
+                if (fCatchOutput)
+                    MkWinChildcareWorkerDrainPipes(pChild, pWorker->pStdOut, pWorker->pStdErr);
+                return dwExitCode;
+            }
+        }
+        /*
+         * Loop again if just a timeout or pending output?
+         * Put out a message every 15 or 30 seconds if the job takes a while.
+         */
+        else if (   dwStatus == WAIT_TIMEOUT
+                 || dwStatus == WAIT_OBJECT_0 + 1
+                 || dwStatus == WAIT_OBJECT_0 + 2
+                 || dwStatus == WAIT_IO_COMPLETION)
+        {
+            DWORD msNow = GetTickCount();
+            if (msNow >= msNextMsg)
+            {
+                if (   !pChild->pMkChild
+                    || !pChild->pMkChild->recursive) /* ignore make recursions */
+                {
+                    if (   !pChild->pMkChild
+                        || !pChild->pMkChild->file
+                        || !pChild->pMkChild->file->name)
+                        MkWinChildError(NULL, 0, "Pid %u ('%ls') still running after %u seconds\n",
+                                        GetProcessId(hProcess), pwszJob, (msNow - msStart) / 1000);
+                    else
+                        MkWinChildError(NULL, 0, "Target '%s' (pid %u) still running after %u seconds\n",
+                                        pChild->pMkChild->file->name, GetProcessId(hProcess), (msNow - msStart) / 1000);
+                }
+
+                /* After 15s, 30s, 60s, 120s, 180s, ... */
+                if (msNextMsg == msStart + 15000)
+                    msNextMsg += 15000;
+                else
+                    msNextMsg += 30000;
+            }
+            continue;
+        }
+
+        /* Something failed. */
+        pChild->iExitCode = GetLastError();
+        if (pChild->iExitCode == 0)
+            pChild->iExitCode = -4242;
+        return pChild->iExitCode;
+    }
+}
+
+
+/**
+ * Closes standard handles that need closing before destruction.
+ *
+ * @param   pChild          The child (WINCHILDTYPE_PROCESS).
+ */
+static void mkWinChildcareWorkerCloseStandardHandles(PWINCHILD pChild)
+{
+    if (   pChild->u.Process.fCloseStdOut
+        && pChild->u.Process.hStdOut != INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(pChild->u.Process.hStdOut);
+        pChild->u.Process.hStdOut      = INVALID_HANDLE_VALUE;
+        pChild->u.Process.fCloseStdOut = FALSE;
+    }
+    if (   pChild->u.Process.fCloseStdErr
+        && pChild->u.Process.hStdErr != INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(pChild->u.Process.hStdErr);
+        pChild->u.Process.hStdErr      = INVALID_HANDLE_VALUE;
+        pChild->u.Process.fCloseStdErr = FALSE;
+    }
+}
+
+
+/**
+ * Does the actual process creation.
+ *
+ * @returns 0 if there is anything to wait on, otherwise non-zero windows error.
+ * @param   pWorker             The childcare worker.
+ * @param   pChild              The child.
+ * @param   pwszImageName       The image path.
+ * @param   pwszCommandLine     The command line.
+ * @param   pwszzEnvironment    The enviornment block.
+ */
+static int mkWinChildcareWorkerCreateProcess(PWINCHILDCAREWORKER pWorker, WCHAR const *pwszImageName,
+                                             WCHAR const *pwszCommandLine, WCHAR const *pwszzEnvironment, WCHAR const *pwszCwd,
+                                             BOOL pafReplace[3], HANDLE pahChild[3], BOOL fCatchOutput, HANDLE *phProcess)
+{
+    PROCESS_INFORMATION ProcInfo;
+    STARTUPINFOW        StartupInfo;
+    DWORD               fFlags       = CREATE_UNICODE_ENVIRONMENT;
+    BOOL const          fHaveHandles = pafReplace[0] | pafReplace[1] | pafReplace[2];
+    BOOL                fRet;
+    DWORD               dwErr;
+#ifdef KMK
+    extern int          process_priority;
+#endif
+
+    /*
+     * Populate startup info.
+     *
+     * Turns out we can get away without passing TRUE for the inherit handles
+     * parameter to CreateProcess when we're not using STARTF_USESTDHANDLES.
+     * At least on NT, which is all worth caring about at this point + context IMO.
+     *
+     * Not inherting the handles is a good thing because it means we won't
+     * accidentally end up with a pipe handle or such intended for a different
+     * child process, potentially causing the EOF/HUP event to be delayed.
+     *
+     * Since the present handle inhertiance requirements only involves standard
+     * output and error, we'll never set the inherit handles flag and instead
+     * do manual handle duplication and planting.
+     */
+    memset(&StartupInfo, 0, sizeof(StartupInfo));
+    StartupInfo.cb = sizeof(StartupInfo);
+    GetStartupInfoW(&StartupInfo);
+    StartupInfo.lpReserved2 = 0; /* No CRT file handle + descriptor info possible, sorry. */
+    StartupInfo.cbReserved2 = 0;
+    if (   !fHaveHandles
+        && !fCatchOutput)
+        StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
+    else
+    {
+        fFlags |= CREATE_SUSPENDED;
+        StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
+    }
+
+    /*
+     * Flags.
+     */
+#ifdef KMK
+    switch (process_priority)
+    {
+        case 1: fFlags |= CREATE_SUSPENDED | IDLE_PRIORITY_CLASS; break;
+        case 2: fFlags |= CREATE_SUSPENDED | BELOW_NORMAL_PRIORITY_CLASS; break;
+        case 3: fFlags |= CREATE_SUSPENDED | NORMAL_PRIORITY_CLASS; break;
+        case 4: fFlags |= CREATE_SUSPENDED | HIGH_PRIORITY_CLASS; break;
+        case 5: fFlags |= CREATE_SUSPENDED | REALTIME_PRIORITY_CLASS; break;
+    }
+#endif
+    if (g_cProcessorGroups > 1)
+        fFlags |= CREATE_SUSPENDED;
+
+    /*
+     * Try create the process.
+     */
+    DB(DB_JOBS, ("CreateProcessW(%ls, %ls,,, TRUE, %#x...)\n", pwszImageName, pwszCommandLine, fFlags));
+    memset(&ProcInfo, 0, sizeof(ProcInfo));
+#ifdef WITH_RW_LOCK
+    AcquireSRWLockShared(&g_RWLock);
+#endif
+
+    fRet = CreateProcessW((WCHAR *)pwszImageName, (WCHAR *)pwszCommandLine, NULL /*pProcSecAttr*/, NULL /*pThreadSecAttr*/,
+                          FALSE /*fInheritHandles*/, fFlags, (WCHAR *)pwszzEnvironment, pwszCwd, &StartupInfo, &ProcInfo);
+    dwErr = GetLastError();
+
+#ifdef WITH_RW_LOCK
+    ReleaseSRWLockShared(&g_RWLock);
+#endif
+    if (fRet)
+        *phProcess = ProcInfo.hProcess;
+    else
+    {
+        MkWinChildError(pWorker, 1, "CreateProcess(%ls) failed: %u\n", pwszImageName, dwErr);
+        return (int)dwErr;
+    }
+
+    /*
+     * If the child is suspended, we've got some adjustment work to be done.
+     */
+    dwErr = ERROR_SUCCESS;
+    if (fFlags & CREATE_SUSPENDED)
+    {
+        /*
+         * First do handle inhertiance as that's the most complicated.
+         */
+        if (fHaveHandles || fCatchOutput)
+        {
+            char szErrMsg[128];
+            if (fCatchOutput)
+            {
+                if (!pafReplace[1])
+                {
+                    pafReplace[1] = TRUE;
+                    pahChild[1]   = pWorker->pStdOut->hPipeChild;
+                }
+                if (!pafReplace[2])
+                {
+                    pafReplace[2] = TRUE;
+                    pahChild[2]   = pWorker->pStdErr->hPipeChild;
+                }
+            }
+            dwErr = nt_child_inject_standard_handles(ProcInfo.hProcess, pafReplace, pahChild, szErrMsg, sizeof(szErrMsg));
+            if (dwErr != 0)
+                MkWinChildError(pWorker, 1, "%s\n", szErrMsg);
+        }
+
+        /*
+         * Assign processor group (ignore failure).
+         */
+#ifdef MKWINCHILD_DO_SET_PROCESSOR_GROUP
+        if (g_cProcessorGroups > 1)
+        {
+            GROUP_AFFINITY Affinity = { 0 /* == all active apparently */, pWorker->iProcessorGroup, { 0, 0, 0 } };
+            fRet = g_pfnSetThreadGroupAffinity(ProcInfo.hThread, &Affinity, NULL);
+            assert(fRet);
+        }
+#endif
+
+#ifdef KMK
+        /*
+         * Set priority (ignore failure).
+         */
+        switch (process_priority)
+        {
+            case 1: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_IDLE); break;
+            case 2: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_BELOW_NORMAL); break;
+            case 3: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_NORMAL); break;
+            case 4: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_HIGHEST); break;
+            case 5: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_TIME_CRITICAL); break;
+            default: fRet = TRUE;
+        }
+        assert(fRet);
+#endif
+
+        /*
+         * Inject the job object if we're in a non-killing mode, to postpone
+         * the closing of the job object and maybe make it more useful.
+         */
+        if (win_job_object_no_kill && g_hJob)
+        {
+            HANDLE hWhatever = INVALID_HANDLE_VALUE;
+            DuplicateHandle(GetCurrentProcess(), g_hJob, ProcInfo.hProcess, &hWhatever, GENERIC_ALL,
+                            TRUE /*bInheritHandle*/, DUPLICATE_SAME_ACCESS);
+        }
+
+        /*
+         * Resume the thread if the adjustments succeeded, otherwise kill it.
+         */
+        if (dwErr == ERROR_SUCCESS)
+        {
+            fRet = ResumeThread(ProcInfo.hThread);
+            assert(fRet);
+            if (!fRet)
+            {
+                dwErr = GetLastError();
+                MkWinChildError(pWorker, 1, "ResumeThread failed on child process: %u\n", dwErr);
+            }
+        }
+        if (dwErr != ERROR_SUCCESS)
+            TerminateProcess(ProcInfo.hProcess, dwErr);
+    }
+
+    /*
+     * Close unnecessary handles and cache the image.
+     */
+    CloseHandle(ProcInfo.hThread);
+    kmk_cache_exec_image_w(pwszImageName);
+    return 0;
+}
+
+/**
+ * Converts a argument vector that has already been quoted correctly.
+ *
+ * The argument vector is typically the result of quote_argv().
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param   pWorker             The childcare worker.
+ * @param   papszArgs           The argument vector to convert.
+ * @param   ppwszCommandLine    Where to return the command line.
+ */
+static int mkWinChildcareWorkerConvertQuotedArgvToCommandline(PWINCHILDCAREWORKER pWorker, char **papszArgs,
+                                                              WCHAR **ppwszCommandLine)
+{
+    WCHAR   *pwszCmdLine;
+    WCHAR   *pwszDst;
+
+    /*
+     * Calc length the converted length.
+     */
+    unsigned cwcNeeded = 1;
+    unsigned i = 0;
+    const char *pszSrc;
+    while ((pszSrc = papszArgs[i]) != NULL)
+    {
+        int cwcThis = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, -1, NULL, 0);
+        if (cwcThis > 0 || *pszSrc == '\0')
+            cwcNeeded += cwcThis + 1;
+        else
+        {
+            DWORD dwErr = GetLastError();
+            MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert argv[%u] (%s): %u\n"), i, pszSrc, dwErr);
+            return dwErr;
+        }
+        i++;
+    }
+
+    /*
+     * Allocate and do the conversion.
+     */
+    pwszCmdLine = pwszDst = (WCHAR *)xmalloc(cwcNeeded * sizeof(WCHAR));
+    i = 0;
+    while ((pszSrc = papszArgs[i]) != NULL)
+    {
+        int cwcThis;
+        if (i > 0)
+        {
+            *pwszDst++ = ' ';
+            cwcNeeded--;
+        }
+
+        cwcThis = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, -1, pwszDst, cwcNeeded);
+        if (!cwcThis && *pszSrc != '\0')
+        {
+            DWORD dwErr = GetLastError();
+            MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert argv[%u] (%s): %u\n"), i, pszSrc, dwErr);
+            free(pwszCmdLine);
+            return dwErr;
+        }
+        if (cwcThis > 0 && pwszDst[cwcThis - 1] == '\0')
+            cwcThis--;
+        pwszDst += cwcThis;
+        cwcNeeded -= cwcThis;
+        i++;
+    }
+    *pwszDst++ = '\0';
+
+    *ppwszCommandLine = pwszCmdLine;
+    return 0;
+}
+
+
+#define MKWCCWCMD_F_CYGWIN_SHELL    1
+#define MKWCCWCMD_F_MKS_SHELL       2
+#define MKWCCWCMD_F_HAVE_SH         4
+#define MKWCCWCMD_F_HAVE_KASH_C     8 /**< kmk_ash -c "..." */
+
+/*
+ * @param   pWorker         The childcare worker if on one, otherwise NULL.
+ */
+static int mkWinChildcareWorkerConvertCommandline(PWINCHILDCAREWORKER pWorker, char **papszArgs, unsigned fFlags,
+                                                  WCHAR **ppwszCommandLine)
+{
+    struct ARGINFO
+    {
+        size_t   cchSrc;
+        size_t   cwcDst;           /**< converted size w/o terminator. */
+        size_t   cwcDstExtra : 24; /**< Only set with fSlowly. */
+        size_t   fSlowly     : 1;
+        size_t   fQuoteIt    : 1;
+        size_t   fEndSlashes : 1; /**< if escapes needed for trailing backslashes. */
+        size_t   fExtraSpace : 1; /**< if kash -c "" needs an extra space before the quote. */
+    }     *paArgInfo;
+    size_t cArgs;
+    size_t i;
+    size_t cwcNeeded;
+    WCHAR *pwszDst;
+    WCHAR *pwszCmdLine;
+
+    /*
+     * Count them first so we can allocate an info array of the stack.
+     */
+    cArgs = 0;
+    while (papszArgs[cArgs] != NULL)
+        cArgs++;
+    paArgInfo = (struct ARGINFO *)alloca(sizeof(paArgInfo[0]) * cArgs);
+
+    /*
+     * Preprocess them and calculate the exact command line length.
+     */
+    cwcNeeded = 1;
+    for (i = 0; i < cArgs; i++)
+    {
+        char  *pszSrc = papszArgs[i];
+        size_t cchSrc = strlen(pszSrc);
+        paArgInfo[i].cchSrc = cchSrc;
+        if (cchSrc == 0)
+        {
+            /* empty needs quoting. */
+            paArgInfo[i].cwcDst      = 2;
+            paArgInfo[i].cwcDstExtra = 0;
+            paArgInfo[i].fSlowly     = 0;
+            paArgInfo[i].fQuoteIt    = 1;
+            paArgInfo[i].fExtraSpace = 0;
+            paArgInfo[i].fEndSlashes = 0;
+        }
+        else
+        {
+            const char *pszSpace  = memchr(pszSrc, ' ', cchSrc);
+            const char *pszTab    = memchr(pszSrc, '\t', cchSrc);
+            const char *pszDQuote = memchr(pszSrc, '"', cchSrc);
+            const char *pszEscape = memchr(pszSrc, '\\', cchSrc);
+            int cwcDst = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, cchSrc + 1, NULL, 0);
+            if (cwcDst >= 0)
+                --cwcDst;
+            else
+            {
+                DWORD dwErr = GetLastError();
+                MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert argv[%u] (%s): %u\n"), i, pszSrc, dwErr);
+                return dwErr;
+            }
+#if 0
+            if (!pszSpace && !pszTab && !pszDQuote && !pszEscape)
+            {
+                /* no special handling needed. */
+                paArgInfo[i].cwcDst      = cwcDst;
+                paArgInfo[i].cwcDstExtra = 0;
+                paArgInfo[i].fSlowly     = 0;
+                paArgInfo[i].fQuoteIt    = 0;
+                paArgInfo[i].fExtraSpace = 0;
+                paArgInfo[i].fEndSlashes = 0;
+            }
+            else if (!pszDQuote && !pszEscape)
+            {
+                /* Just double quote it. */
+                paArgInfo[i].cwcDst      = cwcDst + 2;
+                paArgInfo[i].cwcDstExtra = 0;
+                paArgInfo[i].fSlowly     = 0;
+                paArgInfo[i].fQuoteIt    = 1;
+                paArgInfo[i].fExtraSpace = 0;
+                paArgInfo[i].fEndSlashes = 0;
+            }
+            else
+#endif
+            {
+                /* Complicated, need to scan the string to figure out what to do. */
+                size_t cwcDstExtra;
+                int cBackslashes;
+                char ch;
+
+                paArgInfo[i].fQuoteIt    = 0;
+                paArgInfo[i].fSlowly     = 1;
+                paArgInfo[i].fExtraSpace = 0;
+                paArgInfo[i].fEndSlashes = 0;
+
+                cwcDstExtra  = 0;
+                cBackslashes = 0;
+                while ((ch = *pszSrc++) != '\0')
+                {
+                    switch (ch)
+                    {
+                        default:
+                            cBackslashes = 0;
+                            break;
+
+                        case '\\':
+                            cBackslashes++;
+                            break;
+
+                        case '"':
+                            if (fFlags & (MKWCCWCMD_F_CYGWIN_SHELL | MKWCCWCMD_F_MKS_SHELL))
+                                cwcDstExtra += 1; /* just an extra '"' */
+                            else
+                                cwcDstExtra += 1 + cBackslashes; /* extra '\\' for the '"' and for each preceeding slash. */
+                            cBackslashes = 0;
+                            break;
+
+                        case ' ':
+                        case '\t':
+                            if (!paArgInfo[i].fQuoteIt)
+                            {
+                                paArgInfo[i].fQuoteIt = 1;
+                                cwcDstExtra += 2;
+                            }
+                            cBackslashes = 0;
+                            break;
+                    }
+                }
+
+                /* If we're quoting the argument and it ends with trailing '\\', it/they must be escaped. */
+                if (   cBackslashes > 0
+                    && paArgInfo[i].fQuoteIt
+                    && !(fFlags & (MKWCCWCMD_F_CYGWIN_SHELL | MKWCCWCMD_F_MKS_SHELL)))
+                {
+                    cwcDstExtra += cBackslashes;
+                    paArgInfo[i].fEndSlashes = 1;
+                }
+
+                paArgInfo[i].cwcDst      = cwcDst + cwcDstExtra;
+                paArgInfo[i].cwcDstExtra = cwcDstExtra;
+            }
+        }
+
+        if (   (fFlags & MKWCCWCMD_F_HAVE_KASH_C)
+            && paArgInfo[i].fQuoteIt)
+        {
+            paArgInfo[i].fExtraSpace = 1;
+            paArgInfo[i].cwcDst++;
+            paArgInfo[i].cwcDstExtra++;
+        }
+
+        cwcNeeded += (i != 0) + paArgInfo[i].cwcDst;
+    }
+
+    /*
+     * Allocate the result buffer and do the actual conversion.
+     */
+    pwszDst = pwszCmdLine = (WCHAR *)xmalloc(sizeof(WCHAR) * cwcNeeded);
+    for (i = 0; i < cArgs; i++)
+    {
+        char  *pszSrc = papszArgs[i];
+        size_t cwcDst = paArgInfo[i].cwcDst;
+
+        if (i != 0)
+            *pwszDst++ = L' ';
+
+        if (paArgInfo[i].fQuoteIt)
+        {
+            *pwszDst++ = L'"';
+            cwcDst -= 2;
+        }
+
+        if (!paArgInfo[i].fSlowly)
+        {
+            int cwcDst2 = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, paArgInfo[i].cchSrc, pwszDst, cwcDst + 1);
+            assert(cwcDst2 >= 0);
+            pwszDst += cwcDst;
+        }
+        else
+        {
+            /* Do the conversion into the end of the output buffer, then move
+               it up to where it should be char by char.  */
+            int             cBackslashes;
+            size_t          cwcLeft     = paArgInfo[i].cwcDst - paArgInfo[i].cwcDstExtra;
+            WCHAR volatile *pwchSlowSrc = pwszDst + paArgInfo[i].cwcDstExtra;
+            WCHAR volatile *pwchSlowDst = pwszDst;
+            int cwcDst2 = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, paArgInfo[i].cchSrc,
+                                              (WCHAR *)pwchSlowSrc, cwcLeft + 1);
+            assert(cwcDst2 >= 0);
+
+            cBackslashes = 0;
+            while (cwcLeft-- > 0)
+            {
+                WCHAR wcSrc = *pwchSlowSrc++;
+                if (wcSrc != L'\\' && wcSrc != L'"')
+                    cBackslashes = 0;
+                else if (wcSrc == L'\\')
+                    cBackslashes++;
+                else if (   (fFlags & (MKWCCWCMD_F_CYGWIN_SHELL | MKWCCWCMD_F_HAVE_SH))
+                         ==           (MKWCCWCMD_F_CYGWIN_SHELL | MKWCCWCMD_F_HAVE_SH))
+                {
+                    *pwchSlowDst++ = L'"'; /* cygwin: '"' instead of '\\', no escaped slashes. */
+                    cBackslashes = 0;
+                }
+                else
+                {
+                    if (!(fFlags & (MKWCCWCMD_F_CYGWIN_SHELL | MKWCCWCMD_F_MKS_SHELL)))
+                        cBackslashes += 1; /* one extra escape the '"' and one for each preceeding slash. */
+                    while (cBackslashes > 0)
+                    {
+                        *pwchSlowDst++ = L'\\';
+                        cBackslashes--;
+                    }
+                }
+                *pwchSlowDst++ = wcSrc;
+                assert((uintptr_t)pwchSlowDst <= (uintptr_t)pwchSlowSrc);
+            }
+
+            if (paArgInfo[i].fEndSlashes)
+                while (cBackslashes-- > 0)
+                    *pwchSlowDst++ = L'\\';
+
+            pwszDst += cwcDst;
+            assert(pwszDst == (WCHAR *)pwchSlowDst);
+        }
+
+        if (paArgInfo[i].fExtraSpace)
+            *pwszDst++ = L' ';
+        if (paArgInfo[i].fQuoteIt)
+            *pwszDst++ = L'"';
+    }
+    *pwszDst = L'\0';
+    *ppwszCommandLine = pwszCmdLine;
+    return 0;
+}
+
+static int mkWinChildcareWorkerConvertCommandlineWithShell(PWINCHILDCAREWORKER pWorker, const WCHAR *pwszShell, char **papszArgs,
+                                                           WCHAR **ppwszCommandLine)
+{
+    MkWinChildError(pWorker, 1, "%s: not found!\n", papszArgs[0]);
+//__debugbreak();
+    return ERROR_FILE_NOT_FOUND;
+}
+
+/**
+ * Searches the environment block for the PATH variable.
+ *
+ * @returns Pointer to the path in the block or "." in pwszPathFallback.
+ * @param   pwszzEnv            The UTF-16 environment block to search.
+ * @param   pwszPathFallback    Fallback.
+ */
+static const WCHAR *mkWinChildcareWorkerFindPathValue(const WCHAR *pwszzEnv, WCHAR pwszPathFallback[4])
+{
+    while (*pwszzEnv)
+    {
+        size_t cwcVar = wcslen(pwszzEnv);
+        if (!IS_PATH_ENV_VAR(cwcVar, pwszzEnv))
+            pwszzEnv += cwcVar + 1;
+        else if (cwcVar > 5)
+            return &pwszzEnv[5];
+        else
+            break;
+    }
+    pwszPathFallback[0] = L'.';
+    pwszPathFallback[1] = L'\0';
+    return pwszPathFallback;
+}
+
+/**
+ * Checks if we need to had this executable file to the shell.
+ *
+ * @returns TRUE if it's shell fooder, FALSE if we think windows can handle it.
+ * @param   hFile               Handle to the file in question
+ */
+static BOOL mkWinChildcareWorkerCheckIfNeedShell(HANDLE hFile)
+{
+    /*
+     * Read the first 512 bytes and check for an executable image header.
+     */
+    union
+    {
+        DWORD dwSignature;
+        WORD  wSignature;
+        BYTE  ab[128];
+    } uBuf;
+    DWORD cbRead;
+    uBuf.dwSignature = 0;
+    if (   ReadFile(hFile, &uBuf, sizeof(uBuf), &cbRead, NULL /*pOverlapped*/)
+        && cbRead == sizeof(uBuf))
+    {
+        if (uBuf.wSignature == IMAGE_DOS_SIGNATURE)
+            return FALSE;
+        if (uBuf.dwSignature == IMAGE_NT_SIGNATURE)
+            return FALSE;
+        if (   uBuf.wSignature == IMAGE_OS2_SIGNATURE    /* NE */
+            || uBuf.wSignature == 0x5d4c                 /* LX */
+            || uBuf.wSignature == IMAGE_OS2_SIGNATURE_LE /* LE */)
+            return FALSE;
+    }
+    return TRUE;
+}
+
+/**
+ * Checks if the image path looks like microsoft CL.exe.
+ *
+ * @returns TRUE / FALSE.
+ * @param   pwszImagePath   The executable image path to evalutate.
+ * @param   cwcImagePath    The length of the image path.
+ */
+static BOOL mkWinChildIsProbableClExe(WCHAR const *pwszImagePath, size_t cwcImagePath)
+{
+    assert(pwszImagePath[cwcImagePath] == '\0');
+    return cwcImagePath > 7
+        && (pwszImagePath[cwcImagePath - 7] == L'/' || pwszImagePath[cwcImagePath - 7] == L'\\')
+        && (pwszImagePath[cwcImagePath - 6] == L'c' || pwszImagePath[cwcImagePath - 6] == L'C')
+        && (pwszImagePath[cwcImagePath - 5] == L'l' || pwszImagePath[cwcImagePath - 5] == L'L')
+        &&  pwszImagePath[cwcImagePath - 4] == L'.'
+        && (pwszImagePath[cwcImagePath - 3] == L'e' || pwszImagePath[cwcImagePath - 3] == L'E')
+        && (pwszImagePath[cwcImagePath - 2] == L'x' || pwszImagePath[cwcImagePath - 2] == L'X')
+        && (pwszImagePath[cwcImagePath - 1] == L'e' || pwszImagePath[cwcImagePath - 1] == L'E');
+}
+
+/**
+ * Temporary workaround for seemingly buggy kFsCache.c / dir-nt-bird.c.
+ *
+ * Something is not invalidated / updated correctly!
+ */
+static BOOL mkWinChildcareWorkerIsRegularFileW(PWINCHILDCAREWORKER pWorker, wchar_t const *pwszPath)
+{
+    BOOL fRet = FALSE;
+#ifdef KMK
+    if (utf16_regular_file_p(pwszPath))
+        fRet = TRUE;
+    else
+#endif
+    {
+        /* Don't believe the cache. */
+        DWORD dwAttr = GetFileAttributesW(pwszPath);
+        if (dwAttr != INVALID_FILE_ATTRIBUTES)
+        {
+            if (!(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
+            {
+#ifdef KMK
+                extern void dir_cache_invalid_volatile(void);
+                dir_cache_invalid_volatile();
+                if (utf16_regular_file_p(pwszPath))
+                    MkWinChildError(pWorker, 1, "kFsCache was out of sync! pwszPath=%S\n", pwszPath);
+                else
+                {
+                    dir_cache_invalid_all();
+                    if (utf16_regular_file_p(pwszPath))
+                        MkWinChildError(pWorker, 1, "kFsCache was really out of sync! pwszPath=%S\n", pwszPath);
+                    else
+                        MkWinChildError(pWorker, 1, "kFsCache is really out of sync!! pwszPath=%S\n", pwszPath);
+                }
+#endif
+                fRet = TRUE;
+            }
+        }
+    }
+    return fRet;
+}
+
+
+/**
+ * Tries to locate the image file, searching the path and maybe falling back on
+ * the shell in case it knows more (think cygwin with its own view of the file
+ * system).
+ *
+ * This will also check for shell script, falling back on the shell too to
+ * handle those.
+ *
+ * @returns 0 on success, windows error code on failure.
+ * @param   pWorker         The childcare worker.
+ * @param   pszArg0         The first argument.
+ * @param   pwszSearchPath  In case mkWinChildcareWorkerConvertEnvironment
+ *                          had a chance of locating the search path already.
+ * @param   pwszzEnv        The environment block, in case we need to look for
+ *                          the path.
+ * @param   pszShell        The shell.
+ * @param   ppwszImagePath  Where to return the pointer to the image path.  This
+ *                          could be the shell.
+ * @param   pfNeedShell     Where to return shell vs direct execution indicator.
+ * @param   pfProbableClExe Where to return an indicator of probably CL.EXE.
+ */
+static int mkWinChildcareWorkerFindImage(PWINCHILDCAREWORKER pWorker, char const *pszArg0, WCHAR *pwszSearchPath,
+                                         WCHAR const *pwszzEnv, const char *pszShell,
+                                         WCHAR **ppwszImagePath, BOOL *pfNeedShell, BOOL *pfProbableClExe)
+{
+    /** @todo Slap a cache on this code. We usually end up executing the same
+     *        stuff over and over again (e.g. compilers, linkers, etc).
+     *        Hitting the file system is slow on windows. */
+
+    /*
+     * Convert pszArg0 to unicode so we can work directly on that.
+     */
+    WCHAR     wszArg0[MKWINCHILD_MAX_PATH + 4]; /* +4 for painless '.exe' appending */
+    DWORD     dwErr;
+    size_t    cbArg0  = strlen(pszArg0) + 1;
+    int const cwcArg0 = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszArg0, cbArg0, wszArg0, MKWINCHILD_MAX_PATH);
+    if (cwcArg0 > 0)
+    {
+        HANDLE hFile = INVALID_HANDLE_VALUE;
+        WCHAR  wszPathBuf[MKWINCHILD_MAX_PATH + 4]; /* +4 for painless '.exe' appending */
+        int    cwc;
+
+        /*
+         * If there isn't an .exe suffix, we may have to add one.
+         * Also we ASSUME that .exe suffixes means no hash bang detection needed.
+         */
+        int const fHasExeSuffix = cwcArg0 > CSTRLEN(".exe")
+                               &&  wszArg0[cwcArg0 - 4] == '.'
+                               && (wszArg0[cwcArg0 - 3] == L'e' || wszArg0[cwcArg0 - 3] == L'E')
+                               && (wszArg0[cwcArg0 - 2] == L'x' || wszArg0[cwcArg0 - 2] == L'X')
+                               && (wszArg0[cwcArg0 - 1] == L'e' || wszArg0[cwcArg0 - 1] == L'E');
+
+        /*
+         * If there isn't any path specified, we need to search the PATH env.var.
+         */
+        int const fHasPath =  wszArg0[1] == L':'
+                           || wszArg0[0] == L'\\'
+                           || wszArg0[0] == L'/'
+                           || wmemchr(wszArg0, L'/', cwcArg0)
+                           || wmemchr(wszArg0, L'\\', cwcArg0);
+
+        /* Before we do anything, flip UNIX slashes to DOS ones. */
+        WCHAR *pwc = wszArg0;
+        while ((pwc = wcschr(pwc, L'/')) != NULL)
+            *pwc++ = L'\\';
+
+        /* Don't need to set these all the time... */
+        *pfNeedShell = FALSE;
+        *pfProbableClExe = FALSE;
+
+        /*
+         * If any kind of path is specified in arg0, we will not search the
+         * PATH env.var and can limit ourselves to maybe slapping a .exe on to it.
+         */
+        if (fHasPath)
+        {
+            /*
+             * If relative to a CWD, turn it into an absolute one.
+             */
+            unsigned  cwcPath  = cwcArg0;
+            WCHAR    *pwszPath = wszArg0;
+            if (   *pwszPath != L'\\'
+                && (pwszPath[1] != ':' || pwszPath[2] != L'\\') )
+            {
+                DWORD cwcAbsPath = GetFullPathNameW(wszArg0, MKWINCHILD_MAX_PATH, wszPathBuf, NULL);
+                if (cwcAbsPath > 0)
+                {
+                    cwcPath  = cwcAbsPath + 1; /* include terminator, like MultiByteToWideChar does. */
+                    pwszPath = wszPathBuf;
+                }
+            }
+
+            /*
+             * Check with .exe suffix first.
+             * We don't open .exe files and look for hash bang stuff, we just
+             * assume they are executable images that CreateProcess can deal with.
+             */
+            if (!fHasExeSuffix)
+            {
+                pwszPath[cwcPath - 1] = L'.';
+                pwszPath[cwcPath    ] = L'e';
+                pwszPath[cwcPath + 1] = L'x';
+                pwszPath[cwcPath + 2] = L'e';
+                pwszPath[cwcPath + 3] = L'\0';
+            }
+
+            if (mkWinChildcareWorkerIsRegularFileW(pWorker, pwszPath))
+            {
+                *pfProbableClExe = mkWinChildIsProbableClExe(pwszPath, cwcPath + 4 - 1);
+                return mkWinChildDuplicateUtf16String(pwszPath, cwcPath + 4, ppwszImagePath);
+            }
+
+            /*
+             * If no suffix was specified, try without .exe too, but now we need
+             * to see if it's for the shell or CreateProcess.
+             */
+            if (!fHasExeSuffix)
+            {
+                pwszPath[cwcPath - 1] = L'\0';
+#ifdef KMK
+                if (mkWinChildcareWorkerIsRegularFileW(pWorker, pwszPath))
+#endif
+                {
+                    hFile = CreateFileW(pwszPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE | FILE_SHARE_WRITE,
+                                        NULL /*pSecAttr*/, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+                    if (hFile != INVALID_HANDLE_VALUE)
+                    {
+                        *pfNeedShell = mkWinChildcareWorkerCheckIfNeedShell(hFile);
+                        CloseHandle(hFile);
+                        if (!*pfNeedShell)
+                        {
+                            *pfProbableClExe = mkWinChildIsProbableClExe(pwszPath, cwcPath - 1);
+                            return mkWinChildDuplicateUtf16String(pwszPath, cwcPath, ppwszImagePath);
+                        }
+                    }
+                }
+            }
+        }
+        /*
+         * No path, need to search the PATH env.var. for the executable, maybe
+         * adding an .exe suffix while do so if that is missing.
+         */
+        else
+        {
+            BOOL  fSearchedCwd = FALSE;
+            WCHAR wszPathFallback[4];
+            if (!pwszSearchPath)
+                pwszSearchPath = (WCHAR *)mkWinChildcareWorkerFindPathValue(pwszzEnv, wszPathFallback);
+
+            for (;;)
+            {
+                size_t cwcCombined;
+
+                /*
+                 * Find the end of the current PATH component.
+                 */
+                size_t cwcSkip;
+                WCHAR  wcEnd;
+                size_t cwcComponent = 0;
+                WCHAR  wc;
+                while ((wc = pwszSearchPath[cwcComponent]) != L'\0')
+                {
+                    if (wc != ';' && wc != ':')
+                    { /* likely */ }
+                    else if (wc == ';')
+                        break;
+                    else if (cwcComponent != (pwszSearchPath[cwcComponent] != L'"' ? 1 : 2))
+                        break;
+                   cwcComponent++;
+                }
+                wcEnd = wc;
+
+                /* Trim leading spaces and double quotes. */
+                while (   cwcComponent > 0
+                       && ((wc = *pwszSearchPath) == L'"' || wc == L' ' || wc == L'\t'))
+                {
+                    pwszSearchPath++;
+                    cwcComponent--;
+                }
+                cwcSkip = cwcComponent;
+
+                /* Trim trailing spaces & double quotes. */
+                while (   cwcComponent > 0
+                       && ((wc = pwszSearchPath[cwcComponent - 1]) == L'"' || wc == L' ' || wc == L'\t'))
+                    cwcComponent--;
+
+                /*
+                 * Skip empty components.  Join the component and the filename, making sure to
+                 * resolve any CWD relative stuff first.
+                 */
+                cwcCombined = cwcComponent + 1 + cwcArg0;
+                if (cwcComponent > 0 && cwcCombined <= MKWINCHILD_MAX_PATH)
+                {
+                    /* Copy the component into wszPathBuf, maybe abspath'ing it. */
+                    DWORD  cwcAbsPath = 0;
+                    if (   *pwszSearchPath != L'\\'
+                        && (pwszSearchPath[1] != ':' || pwszSearchPath[2] != L'\\') )
+                    {
+                        /* To save an extra buffer + copying, we'll temporarily modify the PATH
+                           value in our converted UTF-16 environment block.  */
+                        WCHAR const wcSaved = pwszSearchPath[cwcComponent];
+                        pwszSearchPath[cwcComponent] = L'\0';
+                        cwcAbsPath = GetFullPathNameW(pwszSearchPath, MKWINCHILD_MAX_PATH, wszPathBuf, NULL);
+                        pwszSearchPath[cwcComponent] = wcSaved;
+                        if (cwcAbsPath > 0 && cwcAbsPath + 1 + cwcArg0 <= MKWINCHILD_MAX_PATH)
+                            cwcCombined = cwcAbsPath + 1 + cwcArg0;
+                        else
+                            cwcAbsPath = 0;
+                    }
+                    if (cwcAbsPath == 0)
+                    {
+                        memcpy(wszPathBuf, pwszSearchPath, cwcComponent * sizeof(WCHAR));
+                        cwcAbsPath = cwcComponent;
+                    }
+
+                    /* Append the filename. */
+                    if ((wc = wszPathBuf[cwcAbsPath - 1]) == L'\\' || wc == L'/' || wc == L':')
+                    {
+                        memcpy(&wszPathBuf[cwcAbsPath], wszArg0, cwcArg0 * sizeof(WCHAR));
+                        cwcCombined--;
+                    }
+                    else
+                    {
+                        wszPathBuf[cwcAbsPath] = L'\\';
+                        memcpy(&wszPathBuf[cwcAbsPath + 1], wszArg0, cwcArg0 * sizeof(WCHAR));
+                    }
+                    assert(wszPathBuf[cwcCombined - 1] == L'\0');
+
+                    /* DOS slash conversion */
+                    pwc = wszPathBuf;
+                    while ((pwc = wcschr(pwc, L'/')) != NULL)
+                        *pwc++ = L'\\';
+
+                    /*
+                     * Search with exe suffix first.
+                     */
+                    if (!fHasExeSuffix)
+                    {
+                        wszPathBuf[cwcCombined - 1] = L'.';
+                        wszPathBuf[cwcCombined    ] = L'e';
+                        wszPathBuf[cwcCombined + 1] = L'x';
+                        wszPathBuf[cwcCombined + 2] = L'e';
+                        wszPathBuf[cwcCombined + 3] = L'\0';
+                    }
+                    if (mkWinChildcareWorkerIsRegularFileW(pWorker, wszPathBuf))
+                    {
+                        *pfProbableClExe = mkWinChildIsProbableClExe(wszPathBuf, cwcCombined + (fHasExeSuffix ? 0 : 4) - 1);
+                        return mkWinChildDuplicateUtf16String(wszPathBuf, cwcCombined + (fHasExeSuffix ? 0 : 4), ppwszImagePath);
+                    }
+                    if (!fHasExeSuffix)
+                    {
+                        wszPathBuf[cwcCombined - 1] = L'\0';
+#ifdef KMK
+                        if (mkWinChildcareWorkerIsRegularFileW(pWorker, wszPathBuf))
+#endif
+                        {
+                            /*
+                             * Check if the file exists w/o the added '.exe' suffix.  If it does,
+                             * we need to check if we can pass it to CreateProcess or need the shell.
+                             */
+                            hFile = CreateFileW(wszPathBuf, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE | FILE_SHARE_WRITE,
+                                                NULL /*pSecAttr*/, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+                            if (hFile != INVALID_HANDLE_VALUE)
+                            {
+                                *pfNeedShell = mkWinChildcareWorkerCheckIfNeedShell(hFile);
+                                CloseHandle(hFile);
+                                if (!*pfNeedShell)
+                                {
+                                    *pfProbableClExe = mkWinChildIsProbableClExe(wszPathBuf, cwcCombined - 1);
+                                    return mkWinChildDuplicateUtf16String(wszPathBuf, cwcCombined, ppwszImagePath);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                /*
+                 * Advance to the next component.
+                 */
+                if (wcEnd != '\0')
+                    pwszSearchPath += cwcSkip + 1;
+                else if (fSearchedCwd)
+                    break;
+                else
+                {
+                    fSearchedCwd = TRUE;
+                    wszPathFallback[0] = L'.';
+                    wszPathFallback[1] = L'\0';
+                    pwszSearchPath = wszPathFallback;
+                }
+            }
+        }
+
+        /*
+         * We need the shell.  It will take care of finding/reporting missing
+         * image files and such.
+         */
+        *pfNeedShell = TRUE;
+        if (pszShell)
+        {
+            cwc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszShell, strlen(pszShell) + 1, wszPathBuf, MKWINCHILD_MAX_PATH);
+            if (cwc > 0)
+                return mkWinChildDuplicateUtf16String(wszPathBuf, cwc, ppwszImagePath);
+            dwErr = GetLastError();
+            MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert shell (%s): %u\n"), pszShell, dwErr);
+        }
+        else
+        {
+            MkWinChildError(pWorker, 1, "%s: not found!\n", pszArg0);
+            dwErr = ERROR_FILE_NOT_FOUND;
+        }
+    }
+    else
+    {
+        dwErr = GetLastError();
+        MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert argv[0] (%s): %u\n"), pszArg0, dwErr);
+    }
+    return dwErr == ERROR_INSUFFICIENT_BUFFER ? ERROR_FILENAME_EXCED_RANGE : dwErr;
+}
+
+/**
+ * Creates the environment block.
+ *
+ * @returns 0 on success, windows error code on failure.
+ * @param   pWorker         The childcare worker if on one, otherwise NULL.
+ * @param   papszEnv        The environment vector to convert.
+ * @param   cbEnvStrings    The size of the environment strings, iff they are
+ *                          sequential in a block.  Otherwise, zero.
+ * @param   ppwszEnv        Where to return the pointer to the environment
+ *                          block.
+ * @param   ppwszSearchPath Where to return the pointer to the path value
+ *                          within the environment block.  This will not be set
+ *                          if cbEnvStrings is non-zero, more efficient to let
+ *                          mkWinChildcareWorkerFindImage() search when needed.
+ */
+static int mkWinChildcareWorkerConvertEnvironment(PWINCHILDCAREWORKER pWorker, char **papszEnv, size_t cbEnvStrings,
+                                                  WCHAR **ppwszEnv, WCHAR const **ppwszSearchPath)
+{
+    DWORD  dwErr;
+    int    cwcRc;
+    int    cwcDst;
+    WCHAR *pwszzDst;
+
+    *ppwszSearchPath = NULL;
+
+    /*
+     * We've got a little optimization here with help from mkWinChildCopyStringArray.
+     */
+    if (cbEnvStrings)
+    {
+        cwcDst = cbEnvStrings + 32;
+        pwszzDst = (WCHAR *)xmalloc(cwcDst * sizeof(WCHAR));
+        cwcRc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, papszEnv[0], cbEnvStrings, pwszzDst, cwcDst);
+        if (cwcRc != 0)
+        {
+            *ppwszEnv = pwszzDst;
+            return 0;
+        }
+
+        /* Resize the allocation and try again. */
+        dwErr = GetLastError();
+        if (dwErr == ERROR_INSUFFICIENT_BUFFER)
+        {
+            cwcRc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, papszEnv[0], cbEnvStrings, NULL, 0);
+            if (cwcRc > 0)
+                cwcDst = cwcRc + 32;
+            else
+                cwcDst *= 2;
+            pwszzDst = (WCHAR *)xrealloc(pwszzDst, cwcDst);
+            cwcRc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, papszEnv[0], cbEnvStrings, pwszzDst, cwcDst);
+            if (cwcRc != 0)
+            {
+                *ppwszEnv = pwszzDst;
+                return 0;
+            }
+            dwErr = GetLastError();
+        }
+        MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert environment block: %u\n"), dwErr);
+    }
+    /*
+     * Need to convert it string by string.
+     */
+    else
+    {
+        size_t offPathValue = ~(size_t)0;
+        size_t offDst;
+
+        /*
+         * Estimate the size first.
+         */
+        size_t      cEnvVars;
+        size_t      cwcDst = 32;
+        size_t      iVar   = 0;
+        const char *pszSrc;
+        while ((pszSrc = papszEnv[iVar]) != NULL)
+        {
+            cwcDst += strlen(pszSrc) + 1;
+            iVar++;
+        }
+        cEnvVars = iVar;
+
+        /* Allocate estimated WCHARs and convert the variables one by one, reallocating
+           the block as needed. */
+        pwszzDst = (WCHAR *)xmalloc(cwcDst * sizeof(WCHAR));
+        cwcDst--; /* save one wchar for the terminating empty string. */
+        offDst = 0;
+        for (iVar = 0; iVar < cEnvVars; iVar++)
+        {
+            size_t       cwcLeft = cwcDst - offDst;
+            size_t const cbSrc   = strlen(pszSrc = papszEnv[iVar]) + 1;
+            assert(cwcDst >= offDst);
+
+
+            cwcRc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, cbSrc, &pwszzDst[offDst], cwcLeft);
+            if (cwcRc > 0)
+            { /* likely */ }
+            else
+            {
+                dwErr = GetLastError();
+                if (dwErr == ERROR_INSUFFICIENT_BUFFER)
+                {
+                    /* Need more space.  So, calc exacly how much and resize the block accordingly. */
+                    size_t cbSrc2 = cbSrc;
+                    size_t iVar2  = iVar;
+                    cwcLeft = 1;
+                    for (;;)
+                    {
+                        size_t cwcRc2 = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, cbSrc, NULL, 0);
+                        if (cwcRc2 > 0)
+                            cwcLeft += cwcRc2;
+                        else
+                            cwcLeft += cbSrc * 4;
+
+                        /* advance */
+                        iVar2++;
+                        if (iVar2 >= cEnvVars)
+                            break;
+                        pszSrc = papszEnv[iVar2];
+                        cbSrc2 = strlen(pszSrc) + 1;
+                    }
+                    pszSrc = papszEnv[iVar];
+
+                    /* Grow the allocation and repeat the conversion. */
+                    if (offDst + cwcLeft > cwcDst + 1)
+                    {
+                        cwcDst   = offDst + cwcLeft;
+                        pwszzDst = (WCHAR *)xrealloc(pwszzDst, cwcDst * sizeof(WCHAR));
+                        cwcDst--; /* save one wchar for the terminating empty string. */
+                        cwcRc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszSrc, cbSrc, &pwszzDst[offDst], cwcLeft - 1);
+                        if (cwcRc <= 0)
+                            dwErr = GetLastError();
+                    }
+                }
+                if (cwcRc <= 0)
+                {
+                    MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert environment string #%u (%s): %u\n"),
+                                    iVar, pszSrc, dwErr);
+                    free(pwszzDst);
+                    return dwErr;
+                }
+            }
+
+            /* Look for the PATH. */
+            if (   offPathValue == ~(size_t)0
+                && IS_PATH_ENV_VAR(cwcRc, &pwszzDst[offDst]) )
+                offPathValue = offDst + 4 + 1;
+
+            /* Advance. */
+            offDst += cwcRc;
+        }
+        pwszzDst[offDst++] = '\0';
+
+        if (offPathValue != ~(size_t)0)
+            *ppwszSearchPath = &pwszzDst[offPathValue];
+        *ppwszEnv = pwszzDst;
+        return 0;
+    }
+    free(pwszzDst);
+    return dwErr;
+}
+
+/**
+ * Childcare worker: handle regular process.
+ *
+ * @param   pWorker             The worker.
+ * @param   pChild              The kSubmit child.
+ */
+static void mkWinChildcareWorkerThreadHandleProcess(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
+{
+    WCHAR  *pwszSearchPath   = NULL;
+    WCHAR  *pwszzEnvironment = NULL;
+    WCHAR  *pwszCommandLine  = NULL;
+    WCHAR  *pwszImageName    = NULL;
+    BOOL    fNeedShell       = FALSE;
+    BOOL    fProbableClExe   = FALSE;
+    int     rc;
+
+    /*
+     * First we convert the environment so we get the PATH we need to
+     * search for the executable.
+     */
+    rc = mkWinChildcareWorkerConvertEnvironment(pWorker, pChild->u.Process.papszEnv ? pChild->u.Process.papszEnv : environ,
+                                                pChild->u.Process.cbEnvStrings,
+                                                &pwszzEnvironment, &pwszSearchPath);
+    /*
+     * Find the executable and maybe checking if it's a shell script, then
+     * convert it to a command line.
+     */
+    if (rc == 0)
+        rc = mkWinChildcareWorkerFindImage(pWorker, pChild->u.Process.papszArgs[0], pwszSearchPath, pwszzEnvironment,
+                                           pChild->u.Process.pszShell, &pwszImageName, &fNeedShell, &pChild->fProbableClExe);
+    if (rc == 0)
+    {
+        if (!fNeedShell)
+            rc = mkWinChildcareWorkerConvertCommandline(pWorker, pChild->u.Process.papszArgs, 0 /*fFlags*/, &pwszCommandLine);
+        else
+            rc = mkWinChildcareWorkerConvertCommandlineWithShell(pWorker, pwszImageName, pChild->u.Process.papszArgs,
+                                                                 &pwszCommandLine);
+
+        /*
+         * Create the child process.
+         */
+        if (rc == 0)
+        {
+            BOOL afReplace[3] = { FALSE, pChild->u.Process.hStdOut != INVALID_HANDLE_VALUE, pChild->u.Process.hStdErr != INVALID_HANDLE_VALUE };
+            HANDLE ahChild[3] = { INVALID_HANDLE_VALUE, pChild->u.Process.hStdOut, pChild->u.Process.hStdErr };
+            rc = mkWinChildcareWorkerCreateProcess(pWorker, pwszImageName, pwszCommandLine, pwszzEnvironment,
+                                                   NULL /*pwszCwd*/, afReplace, ahChild, pChild->u.Process.fCatchOutput,
+                                                   &pChild->u.Process.hProcess);
+            mkWinChildcareWorkerCloseStandardHandles(pChild);
+            if (rc == 0)
+            {
+                /*
+                 * Wait for the child to complete.
+                 */
+                mkWinChildcareWorkerWaitForProcess(pWorker, pChild, pChild->u.Process.hProcess, pwszImageName,
+                                                   pChild->u.Process.fCatchOutput);
+            }
+            else
+                pChild->iExitCode = rc;
+        }
+        else
+            pChild->iExitCode = rc;
+    }
+    else
+        pChild->iExitCode = rc;
+    free(pwszCommandLine);
+    free(pwszImageName);
+    free(pwszzEnvironment);
+
+    /* In case we failed, we must make sure the child end of pipes
+       used by $(shell no_such_command.exe) are closed, otherwise
+       the main thread will be stuck reading the parent end.  */
+    mkWinChildcareWorkerCloseStandardHandles(pChild);
+}
+
+#ifdef KMK
+
+/**
+ * Childcare worker: handle builtin command.
+ *
+ * @param   pWorker             The worker.
+ * @param   pChild              The kSubmit child.
+ */
+static void mkWinChildcareWorkerThreadHandleBuiltIn(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
+{
+    PCKMKBUILTINENTRY pBuiltIn = pChild->u.BuiltIn.pBuiltIn;
+    KMKBUILTINCTX Ctx =
+    {
+        pBuiltIn->uName.s.sz,
+        pChild->pMkChild ? &pChild->pMkChild->output : NULL,
+        pWorker,
+    };
+    if (pBuiltIn->uFnSignature == FN_SIG_MAIN)
+        pChild->iExitCode = pBuiltIn->u.pfnMain(pChild->u.BuiltIn.cArgs, pChild->u.BuiltIn.papszArgs,
+                                                pChild->u.BuiltIn.papszEnv, &Ctx);
+    else if (pBuiltIn->uFnSignature == FN_SIG_MAIN_SPAWNS)
+        pChild->iExitCode = pBuiltIn->u.pfnMainSpawns(pChild->u.BuiltIn.cArgs, pChild->u.BuiltIn.papszArgs,
+                                                      pChild->u.BuiltIn.papszEnv, &Ctx, pChild->pMkChild, NULL /*pPid*/);
+    else
+    {
+        assert(0);
+        pChild->iExitCode = 98;
+    }
+}
+
+/**
+ * Childcare worker: handle append write-out.
+ *
+ * @param   pWorker             The worker.
+ * @param   pChild              The kSubmit child.
+ */
+static void mkWinChildcareWorkerThreadHandleAppend(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
+{
+    int fd = open(pChild->u.Append.pszFilename,
+                  pChild->u.Append.fTruncate
+                  ? O_WRONLY | O_TRUNC  | O_CREAT | _O_NOINHERIT | _O_BINARY
+                  : O_WRONLY | O_APPEND | O_CREAT | _O_NOINHERIT | _O_BINARY,
+                  0666);
+    if (fd >= 0)
+    {
+        ssize_t cbWritten = write(fd, pChild->u.Append.pszAppend, pChild->u.Append.cbAppend);
+        if (cbWritten == (ssize_t)pChild->u.Append.cbAppend)
+        {
+            if (close(fd) >= 0)
+            {
+                pChild->iExitCode = 0;
+                return;
+            }
+            MkWinChildError(pWorker, 1, "kmk_builtin_append: close failed on '%s': %u (%s)\n",
+                            pChild->u.Append.pszFilename, errno, strerror(errno));
+        }
+        else
+            MkWinChildError(pWorker, 1, "kmk_builtin_append: error writing %lu bytes to on '%s': %u (%s)\n",
+                            pChild->u.Append.cbAppend, pChild->u.Append.pszFilename, errno, strerror(errno));
+        close(fd);
+    }
+    else
+        MkWinChildError(pWorker, 1, "kmk_builtin_append: error opening '%s': %u (%s)\n",
+                        pChild->u.Append.pszFilename, errno, strerror(errno));
+    pChild->iExitCode = 1;
+}
+
+/**
+ * Childcare worker: handle kSubmit job.
+ *
+ * @param   pWorker             The worker.
+ * @param   pChild              The kSubmit child.
+ */
+static void mkWinChildcareWorkerThreadHandleSubmit(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
+{
+    void  *pvSubmitWorker = pChild->u.Submit.pvSubmitWorker;
+
+    /*
+     * Prep the wait handles.
+     */
+    HANDLE ahHandles[3]   = { pChild->u.Submit.hEvent, NULL, NULL };
+    DWORD  cHandles       = 1;
+    if (pChild->u.Submit.pStdOut)
+    {
+        assert(pChild->u.Submit.pStdErr);
+        pChild->u.Submit.pStdOut->fHaveWrittenOut = FALSE;
+        ahHandles[cHandles++] = pChild->u.Submit.pStdOut->hEvent;
+        pChild->u.Submit.pStdErr->fHaveWrittenOut = FALSE;
+        ahHandles[cHandles++] = pChild->u.Submit.pStdErr->hEvent;
+    }
+
+    /*
+     * Wait loop.
+     */
+    for (;;)
+    {
+        int   iExitCode = -42;
+        int   iSignal   = -1;
+        DWORD dwStatus;
+        if (cHandles == 1)
+            dwStatus = WaitForSingleObject(ahHandles[0], INFINITE);
+        else
+        {
+            dwStatus = WaitForMultipleObjects(cHandles, ahHandles, FALSE /*fWaitAll*/, INFINITE);
+            assert(dwStatus != WAIT_FAILED);
+            if (dwStatus == WAIT_OBJECT_0 + 1)
+                mkWinChildcareWorkerCatchOutput(pChild, pChild->u.Submit.pStdOut, FALSE /*fDraining*/);
+            else if (dwStatus == WAIT_OBJECT_0 + 2)
+                mkWinChildcareWorkerCatchOutput(pChild, pChild->u.Submit.pStdErr, FALSE /*fDraining*/);
+        }
+        if (kSubmitSubProcGetResult((intptr_t)pvSubmitWorker, dwStatus == WAIT_OBJECT_0 /*fBlock*/, &iExitCode, &iSignal) == 0)
+        {
+            if (pChild->u.Submit.pStdOut)
+                MkWinChildcareWorkerDrainPipes(pChild, pChild->u.Submit.pStdOut, pChild->u.Submit.pStdErr);
+
+            pChild->iExitCode = iExitCode;
+            pChild->iSignal   = iSignal;
+            /* Cleanup must be done on the main thread. */
+            return;
+        }
+
+        if (pChild->iSignal != 0)
+            kSubmitSubProcKill((intptr_t)pvSubmitWorker, pChild->iSignal);
+    }
+}
+
+/**
+ * Childcare worker: handle kmk_redirect process.
+ *
+ * @param   pWorker             The worker.
+ * @param   pChild              The redirect child.
+ */
+static void mkWinChildcareWorkerThreadHandleRedirect(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
+{
+    mkWinChildcareWorkerWaitForProcess(pWorker, pChild, pChild->u.Redirect.hProcess, L"kmk_redirect", FALSE /*fCatchOutput*/);
+}
+
+#endif /* KMK */
+
+/**
+ * Childcare worker thread.
+ *
+ * @returns 0
+ * @param   pvUser              The worker instance.
+ */
+static unsigned int __stdcall mkWinChildcareWorkerThread(void *pvUser)
+{
+    PWINCHILDCAREWORKER pWorker = (PWINCHILDCAREWORKER)pvUser;
+    assert(pWorker->uMagic == WINCHILDCAREWORKER_MAGIC);
+
+#ifdef MKWINCHILD_DO_SET_PROCESSOR_GROUP
+    /*
+     * Adjust process group if necessary.
+     *
+     * Note! It seems that setting the mask to zero means that we select all
+     *       active processors.  Couldn't find any alternative API for getting
+     *       the correct active processor mask.
+     */
+    if (g_cProcessorGroups > 1)
+    {
+        GROUP_AFFINITY Affinity = { 0 /* == all active apparently */, pWorker->iProcessorGroup, { 0, 0, 0 } };
+        BOOL fRet = g_pfnSetThreadGroupAffinity(GetCurrentThread(), &Affinity, NULL);
+        assert(fRet); (void)fRet;
+# ifndef NDEBUG
+        {
+            GROUP_AFFINITY ActualAffinity = { 0xbeefbeefU, 0xbeef, { 0xbeef, 0xbeef, 0xbeef } };
+            fRet = GetThreadGroupAffinity(GetCurrentThread(), &ActualAffinity);
+            assert(fRet); (void)fRet;
+            assert(ActualAffinity.Group == pWorker->iProcessorGroup);
+        }
+# endif
+    }
+#endif
+
+    /*
+     * Work loop.
+     */
+    while (!g_fShutdown)
+    {
+        /*
+         * Try go idle.
+         */
+        PWINCHILD pChild = pWorker->pTailTodoChildren;
+        if (!pChild)
+        {
+            _InterlockedExchange(&pWorker->fIdle, TRUE);
+            pChild = pWorker->pTailTodoChildren;
+            if (!pChild)
+            {
+                DWORD dwStatus;
+
+                _InterlockedIncrement((long *)&g_cIdleChildcareWorkers);
+                _InterlockedExchange((long *)&g_idxLastChildcareWorker, pWorker->idxWorker);
+                dwStatus = WaitForSingleObject(pWorker->hEvtIdle, INFINITE);
+                _InterlockedExchange(&pWorker->fIdle, FALSE);
+                _InterlockedDecrement((long *)&g_cIdleChildcareWorkers);
+
+                assert(dwStatus != WAIT_FAILED);
+                if (dwStatus == WAIT_FAILED)
+                    Sleep(20);
+
+                pChild = pWorker->pTailTodoChildren;
+            }
+            else
+                _InterlockedExchange(&pWorker->fIdle, FALSE);
+        }
+        if (pChild)
+        {
+            /*
+             * We got work to do.  First job is to deque the job.
+             */
+            pChild = mkWinChildDequeFromLifo(&pWorker->pTailTodoChildren, pChild);
+            assert(pChild);
+            if (pChild)
+            {
+                PWINCHILD pTailExpect;
+
+                pChild->pWorker = pWorker;
+                pWorker->pCurChild = pChild;
+                switch (pChild->enmType)
+                {
+                    case WINCHILDTYPE_PROCESS:
+                        mkWinChildcareWorkerThreadHandleProcess(pWorker, pChild);
+                        break;
+#ifdef KMK
+                    case WINCHILDTYPE_BUILT_IN:
+                        mkWinChildcareWorkerThreadHandleBuiltIn(pWorker, pChild);
+                        break;
+                    case WINCHILDTYPE_APPEND:
+                        mkWinChildcareWorkerThreadHandleAppend(pWorker, pChild);
+                        break;
+                    case WINCHILDTYPE_SUBMIT:
+                        mkWinChildcareWorkerThreadHandleSubmit(pWorker, pChild);
+                        break;
+                    case WINCHILDTYPE_REDIRECT:
+                        mkWinChildcareWorkerThreadHandleRedirect(pWorker, pChild);
+                        break;
+#endif
+                    default:
+                        assert(0);
+                }
+                pWorker->pCurChild = NULL;
+                pChild->pWorker = NULL;
+
+                /*
+                 * Move the child to the completed list.
+                 */
+                pTailExpect = NULL;
+                for (;;)
+                {
+                    PWINCHILD pTailActual;
+                    pChild->pNext = pTailExpect;
+                    pTailActual = _InterlockedCompareExchangePointer(&g_pTailCompletedChildren, pChild, pTailExpect);
+                    if (pTailActual != pTailExpect)
+                        pTailExpect = pTailActual;
+                    else
+                    {
+                        _InterlockedDecrement(&g_cPendingChildren);
+                        if (pTailExpect)
+                            break;
+                        if (SetEvent(g_hEvtWaitChildren))
+                            break;
+                        MkWinChildError(pWorker, 1, "SetEvent(g_hEvtWaitChildren=%p) failed: %u\n",
+                                        g_hEvtWaitChildren, GetLastError());
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    _endthreadex(0);
+    return 0;
+}
+
+/**
+ * Creates a pipe for catching child output.
+ *
+ * This is a custom CreatePipe implementation that allows for overlapped I/O on
+ * our end of the pipe.  Silly that they don't offer an API that does this.
+ *
+ * @returns The pipe that was created. NULL on failure.
+ * @param   pPipe               The structure for the pipe.
+ * @param   iWhich              Which standard descriptor this is a pipe for.
+ * @param   idxWorker           The worker index.
+ */
+PWINCCWPIPE MkWinChildcareCreateWorkerPipe(unsigned iWhich, unsigned int idxWorker)
+{
+    /*
+     * We try generate a reasonably unique name from the get go, so this retry
+     * loop shouldn't really ever be needed.  But you never know.
+     */
+    static unsigned s_iSeqNo = 0;
+    DWORD const     cMaxInstances = 1;
+    DWORD const     cbPipe        = 4096;
+    DWORD const     cMsTimeout    = 0;
+    unsigned        cTries        = 256;
+    while (cTries-- > 0)
+    {
+        /* Create the pipe (our end). */
+        HANDLE hPipeRead;
+        DWORD  fOpenMode = PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE;
+        DWORD  fPipeMode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS;
+        WCHAR  wszName[MAX_PATH];
+        s_iSeqNo++;
+        _snwprintf(wszName, MAX_PATH, L"\\\\.\\pipe\\kmk-winchildren-%u-%u-%u-%s-%u-%u",
+                   GetCurrentProcessId(), GetCurrentThreadId(), idxWorker, iWhich == 1 ? L"out" : L"err", s_iSeqNo, GetTickCount());
+        hPipeRead = CreateNamedPipeW(wszName, fOpenMode, fPipeMode, cMaxInstances, cbPipe, cbPipe, cMsTimeout, NULL /*pSecAttr*/);
+        if (hPipeRead == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_PARAMETER)
+        {
+            fOpenMode &= ~FILE_FLAG_FIRST_PIPE_INSTANCE;
+            fPipeMode &= ~PIPE_REJECT_REMOTE_CLIENTS;
+            hPipeRead = CreateNamedPipeW(wszName, fOpenMode, fPipeMode, cMaxInstances, cbPipe, cbPipe, cMsTimeout, NULL /*pSecAttr*/);
+        }
+        if (hPipeRead != INVALID_HANDLE_VALUE)
+        {
+            /* Connect the other end. */
+            HANDLE hPipeWrite = CreateFileW(wszName, GENERIC_WRITE | FILE_READ_ATTRIBUTES, 0 /*fShareMode*/, NULL /*pSecAttr*/,
+                                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL /*hTemplateFile*/);
+            if (hPipeWrite != INVALID_HANDLE_VALUE)
+            {
+                /*
+                 * Create the event object and we're done.
+                 *
+                 * It starts in signalled stated so we don't need special code
+                 * for handing when we start waiting.
+                 */
+                HANDLE hEvent = CreateEventW(NULL /*pSecAttr*/, TRUE /*fManualReset*/, TRUE /*fInitialState*/, NULL /*pwszName*/);
+                if (hEvent != NULL)
+                {
+                    PWINCCWPIPE pPipe = (PWINCCWPIPE)xcalloc(sizeof(*pPipe));
+                    pPipe->hPipeMine    = hPipeRead;
+                    pPipe->hPipeChild   = hPipeWrite;
+                    pPipe->hEvent       = hEvent;
+                    pPipe->iWhich       = iWhich;
+                    pPipe->fReadPending = FALSE;
+                    pPipe->cbBuffer     = cbPipe;
+                    pPipe->pbBuffer     = xcalloc(cbPipe);
+                    return pPipe;
+                }
+
+                CloseHandle(hPipeWrite);
+                CloseHandle(hPipeRead);
+                return NULL;
+            }
+            CloseHandle(hPipeRead);
+        }
+    }
+    return NULL;
+}
+
+/**
+ * Destroys a childcare worker pipe.
+ *
+ * @param   pPipe       The pipe.
+ */
+void MkWinChildcareDeleteWorkerPipe(PWINCCWPIPE pPipe)
+{
+    if (pPipe->hPipeChild != NULL)
+    {
+        CloseHandle(pPipe->hPipeChild);
+        pPipe->hPipeChild = NULL;
+    }
+
+    if (pPipe->hPipeMine != NULL)
+    {
+        if (pPipe->fReadPending)
+            if (!CancelIo(pPipe->hPipeMine))
+                WaitForSingleObject(pPipe->hEvent, INFINITE);
+        CloseHandle(pPipe->hPipeMine);
+        pPipe->hPipeMine = NULL;
+    }
+
+    if (pPipe->hEvent != NULL)
+    {
+        CloseHandle(pPipe->hEvent);
+        pPipe->hEvent = NULL;
+    }
+
+    if (pPipe->pbBuffer)
+    {
+        free(pPipe->pbBuffer);
+        pPipe->pbBuffer = NULL;
+    }
+}
+
+/**
+ * Initializes the processor group allocator.
+ *
+ * @param   pState              The allocator to initialize.
+ */
+void MkWinChildInitCpuGroupAllocator(PMKWINCHILDCPUGROUPALLOCSTATE pState)
+{
+    /* We shift the starting group with the make nesting level as part of
+       our very simple distribution strategy. */
+    pState->idxGroup = makelevel;
+    pState->idxProcessorInGroup = 0;
+}
+
+/**
+ * Allocate CPU group for the next child process.
+ *
+ * @returns CPU group.
+ * @param   pState              The allocator state.  Must be initialized by
+ *                              MkWinChildInitCpuGroupAllocator().
+ */
+unsigned int MkWinChildAllocateCpuGroup(PMKWINCHILDCPUGROUPALLOCSTATE pState)
+{
+    unsigned int iGroup = 0;
+    if (g_cProcessorGroups > 1)
+    {
+        unsigned int cMaxInGroup;
+        unsigned int cInGroup;
+
+        iGroup = pState->idxGroup % g_cProcessorGroups;
+
+        /* Advance.  We employ a very simple strategy that does 50% in
+           each group for each group cycle.  Odd processor counts are
+           caught in odd group cycles.  The init function selects the
+           starting group based on make nesting level to avoid stressing
+           out the first group. */
+        cInGroup = ++pState->idxProcessorInGroup;
+        cMaxInGroup = g_pacProcessorsInGroup[iGroup];
+        if (   !(cMaxInGroup & 1)
+            || !((pState->idxGroup / g_cProcessorGroups) & 1))
+            cMaxInGroup /= 2;
+        else
+            cMaxInGroup = cMaxInGroup / 2 + 1;
+        if (cInGroup >= cMaxInGroup)
+        {
+            pState->idxProcessorInGroup = 0;
+            pState->idxGroup++;
+        }
+    }
+    return iGroup;
+}
+
+/**
+ * Creates another childcare worker.
+ *
+ * @returns The new worker, if we succeeded.
+ */
+static PWINCHILDCAREWORKER mkWinChildcareCreateWorker(void)
+{
+    PWINCHILDCAREWORKER pWorker = (PWINCHILDCAREWORKER)xcalloc(sizeof(*pWorker));
+    pWorker->uMagic    = WINCHILDCAREWORKER_MAGIC;
+    pWorker->idxWorker = g_cChildCareworkers;
+    pWorker->hEvtIdle  = CreateEventW(NULL, FALSE /*fManualReset*/, FALSE /*fInitialState*/, NULL /*pwszName*/);
+    if (pWorker->hEvtIdle)
+    {
+        pWorker->pStdOut = MkWinChildcareCreateWorkerPipe(1, pWorker->idxWorker);
+        if (pWorker->pStdOut)
+        {
+            pWorker->pStdErr = MkWinChildcareCreateWorkerPipe(2, pWorker->idxWorker);
+            if (pWorker->pStdErr)
+            {
+                /* Before we start the thread, assign it to a processor group. */
+                pWorker->iProcessorGroup = MkWinChildAllocateCpuGroup(&g_ProcessorGroupAllocator);
+
+                /* Try start the thread. */
+                pWorker->hThread = (HANDLE)_beginthreadex(NULL, 0 /*cbStack*/, mkWinChildcareWorkerThread, pWorker,
+                                                          0, &pWorker->tid);
+                if (pWorker->hThread != NULL)
+                {
+                    pWorker->idxWorker = g_cChildCareworkers++; /* paranoia */
+                    g_papChildCareworkers[pWorker->idxWorker] = pWorker;
+                    return pWorker;
+                }
+
+                /* Bail out! */
+                ONS (error, NILF, "_beginthreadex failed: %u (%s)\n", errno, strerror(errno));
+                MkWinChildcareDeleteWorkerPipe(pWorker->pStdErr);
+            }
+            else
+                ON (error, NILF, "Failed to create stderr pipe: %u\n", GetLastError());
+            MkWinChildcareDeleteWorkerPipe(pWorker->pStdOut);
+        }
+        else
+            ON (error, NILF, "Failed to create stdout pipe: %u\n", GetLastError());
+        CloseHandle(pWorker->hEvtIdle);
+    }
+    else
+        ON (error, NILF, "CreateEvent failed: %u\n", GetLastError());
+    pWorker->uMagic = ~WINCHILDCAREWORKER_MAGIC;
+    free(pWorker);
+    return NULL;
+}
+
+/**
+ * Helper for copying argument and environment vectors.
+ *
+ * @returns Single alloc block copy.
+ * @param   papszSrc    The source vector.
+ * @param   pcbStrings  Where to return the size of the strings & terminator.
+ */
+static char **mkWinChildCopyStringArray(char **papszSrc, size_t *pcbStrings)
+{
+    const char *psz;
+    char      **papszDstArray;
+    char       *pszDstStr;
+    size_t      i;
+
+    /* Calc sizes first. */
+    size_t      cbStrings = 1; /* (one extra for terminator string) */
+    size_t      cStrings = 0;
+    while ((psz = papszSrc[cStrings]) != NULL)
+    {
+        cbStrings += strlen(psz) + 1;
+        cStrings++;
+    }
+    *pcbStrings = cbStrings;
+
+    /* Allocate destination. */
+    papszDstArray = (char **)xmalloc(cbStrings + (cStrings + 1) * sizeof(papszDstArray[0]));
+    pszDstStr = (char *)&papszDstArray[cStrings + 1];
+
+    /* Copy it. */
+    for (i = 0; i < cStrings; i++)
+    {
+        const char *pszSource = papszSrc[i];
+        size_t      cchString = strlen(pszSource);
+        papszDstArray[i] = pszDstStr;
+        memcpy(pszDstStr, pszSource, cchString);
+        pszDstStr += cchString;
+        *pszDstStr++ = '\0';
+    }
+    *pszDstStr = '\0';
+    assert(&pszDstStr[1] - papszDstArray[0] == cbStrings);
+    papszDstArray[i] = NULL;
+    return papszDstArray;
+}
+
+/**
+ * Allocate and init a WINCHILD.
+ *
+ * @returns The new windows child structure.
+ * @param   enmType         The child type.
+ */
+static PWINCHILD mkWinChildNew(WINCHILDTYPE enmType)
+{
+    PWINCHILD pChild = xcalloc(sizeof(*pChild));
+    pChild->enmType     = enmType;
+    pChild->fCoreDumped = 0;
+    pChild->iSignal     = 0;
+    pChild->iExitCode   = 222222;
+    pChild->uMagic      = WINCHILD_MAGIC;
+    pChild->pid         = (intptr_t)pChild;
+    return pChild;
+}
+
+/**
+ * Destructor for WINCHILD.
+ *
+ * @param   pChild              The child structure to destroy.
+ */
+static void mkWinChildDelete(PWINCHILD pChild)
+{
+    assert(pChild->uMagic == WINCHILD_MAGIC);
+    pChild->uMagic = ~WINCHILD_MAGIC;
+
+    switch (pChild->enmType)
+    {
+        case WINCHILDTYPE_PROCESS:
+        {
+            if (pChild->u.Process.papszArgs)
+            {
+                free(pChild->u.Process.papszArgs);
+                pChild->u.Process.papszArgs = NULL;
+            }
+            if (pChild->u.Process.cbEnvStrings && pChild->u.Process.papszEnv)
+            {
+                free(pChild->u.Process.papszEnv);
+                pChild->u.Process.papszEnv = NULL;
+            }
+            if (pChild->u.Process.pszShell)
+            {
+                free(pChild->u.Process.pszShell);
+                pChild->u.Process.pszShell = NULL;
+            }
+            if (pChild->u.Process.hProcess)
+            {
+                CloseHandle(pChild->u.Process.hProcess);
+                pChild->u.Process.hProcess = NULL;
+            }
+            mkWinChildcareWorkerCloseStandardHandles(pChild);
+            break;
+        }
+
+#ifdef KMK
+        case WINCHILDTYPE_BUILT_IN:
+            if (pChild->u.BuiltIn.papszArgs)
+            {
+                free(pChild->u.BuiltIn.papszArgs);
+                pChild->u.BuiltIn.papszArgs = NULL;
+            }
+            if (pChild->u.BuiltIn.papszEnv)
+            {
+                free(pChild->u.BuiltIn.papszEnv);
+                pChild->u.BuiltIn.papszEnv = NULL;
+            }
+            break;
+
+        case WINCHILDTYPE_APPEND:
+            if (pChild->u.Append.pszFilename)
+            {
+                free(pChild->u.Append.pszFilename);
+                pChild->u.Append.pszFilename = NULL;
+            }
+            if (pChild->u.Append.pszAppend)
+            {
+                free(pChild->u.Append.pszAppend);
+                pChild->u.Append.pszAppend = NULL;
+            }
+            break;
+
+        case WINCHILDTYPE_SUBMIT:
+            if (pChild->u.Submit.pvSubmitWorker)
+            {
+                kSubmitSubProcCleanup((intptr_t)pChild->u.Submit.pvSubmitWorker);
+                pChild->u.Submit.pvSubmitWorker = NULL;
+            }
+            break;
+
+        case WINCHILDTYPE_REDIRECT:
+            if (pChild->u.Redirect.hProcess)
+            {
+                CloseHandle(pChild->u.Redirect.hProcess);
+                pChild->u.Redirect.hProcess = NULL;
+            }
+            break;
+#endif /* KMK */
+
+        default:
+            assert(0);
+    }
+
+    free(pChild);
+}
+
+/**
+ * Queues the child with a worker, creating new workers if necessary.
+ *
+ * @returns 0 on success, windows error code on failure (child destroyed).
+ * @param   pChild          The child.
+ * @param   pPid            Where to return the PID (optional).
+ */
+static int mkWinChildPushToCareWorker(PWINCHILD pChild, pid_t *pPid)
+{
+    PWINCHILDCAREWORKER pWorker = NULL;
+    PWINCHILD pOldChild;
+    PWINCHILD pCurChild;
+
+    /*
+     * There are usually idle workers around, except for at the start.
+     */
+    if (g_cIdleChildcareWorkers > 0)
+    {
+        /*
+         * Try the idle hint first and move forward from it.
+         */
+        unsigned int const cWorkers = g_cChildCareworkers;
+        unsigned int       iHint    = g_idxLastChildcareWorker;
+        unsigned int       i;
+        for (i = iHint; i < cWorkers; i++)
+        {
+            PWINCHILDCAREWORKER pPossibleWorker = g_papChildCareworkers[i];
+            if (pPossibleWorker->fIdle)
+            {
+                pWorker = pPossibleWorker;
+                break;
+            }
+        }
+        if (!pWorker)
+        {
+            /* Scan from the start. */
+            if (iHint > cWorkers)
+                iHint = cWorkers;
+            for (i = 0; i < iHint; i++)
+            {
+                PWINCHILDCAREWORKER pPossibleWorker = g_papChildCareworkers[i];
+                if (pPossibleWorker->fIdle)
+                {
+                    pWorker = pPossibleWorker;
+                    break;
+                }
+            }
+        }
+    }
+    if (!pWorker)
+    {
+        /*
+         * Try create more workers if we haven't reached the max yet.
+         */
+        if (g_cChildCareworkers < g_cChildCareworkersMax)
+            pWorker = mkWinChildcareCreateWorker();
+
+        /*
+         * Queue it with an existing worker.  Look for one without anthing extra scheduled.
+         */
+        if (!pWorker)
+        {
+            unsigned int i = g_cChildCareworkers;
+            if (i == 0)
+                fatal(NILF, 0, _("Failed to create worker threads for managing child processes!\n"));
+            pWorker = g_papChildCareworkers[--i];
+            if (pWorker->pTailTodoChildren)
+                while (i-- > 0)
+                {
+                    PWINCHILDCAREWORKER pPossibleWorker = g_papChildCareworkers[i];
+                    if (!pPossibleWorker->pTailTodoChildren)
+                    {
+                        pWorker = pPossibleWorker;
+                        break;
+                    }
+                }
+        }
+    }
+
+    /*
+     * Do the queueing.
+     */
+    pOldChild = NULL;
+    for (;;)
+    {
+        pChild->pNext = pOldChild;
+        pCurChild = _InterlockedCompareExchangePointer((void **)&pWorker->pTailTodoChildren, pChild, pOldChild);
+        if (pCurChild == pOldChild)
+        {
+            DWORD volatile dwErr;
+            _InterlockedIncrement(&g_cPendingChildren);
+            if (   !pWorker->fIdle
+                || SetEvent(pWorker->hEvtIdle))
+            {
+                *pPid = pChild->pid;
+                return 0;
+            }
+
+            _InterlockedDecrement(&g_cPendingChildren);
+            dwErr = GetLastError();
+            assert(0);
+            mkWinChildDelete(pChild);
+            return dwErr ? dwErr : -20;
+        }
+        pOldChild = pCurChild;
+    }
+}
+
+/**
+ * Creates a regular child process (job.c).
+ *
+ * Will copy the information and push it to a childcare thread that does the
+ * actual process creation.
+ *
+ * @returns 0 on success, windows status code on failure.
+ * @param   papszArgs           The arguments.
+ * @param   papszEnv            The environment (optional).
+ * @param   pszShell            The SHELL variable value (optional).
+ * @param   pMkChild            The make child structure (optional).
+ * @param   pPid                Where to return the pid.
+ */
+int MkWinChildCreate(char **papszArgs, char **papszEnv, const char *pszShell, struct child *pMkChild, pid_t *pPid)
+{
+    PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_PROCESS);
+    pChild->pMkChild = pMkChild;
+
+    pChild->u.Process.papszArgs = mkWinChildCopyStringArray(papszArgs, &pChild->u.Process.cbArgsStrings);
+    if (   !papszEnv
+        || !pMkChild
+        || pMkChild->environment == papszEnv)
+    {
+        pChild->u.Process.cbEnvStrings = 0;
+        pChild->u.Process.papszEnv = papszEnv;
+    }
+    else
+        pChild->u.Process.papszEnv = mkWinChildCopyStringArray(papszEnv, &pChild->u.Process.cbEnvStrings);
+    if (pszShell)
+        pChild->u.Process.pszShell = xstrdup(pszShell);
+    pChild->u.Process.hStdOut = INVALID_HANDLE_VALUE;
+    pChild->u.Process.hStdErr = INVALID_HANDLE_VALUE;
+
+    /* We always catch the output in order to prevent character soups courtesy
+       of the microsoft CRT and/or linkers writing character by character to the
+       console.  Always try write whole lines, even when --output-sync is none. */
+    pChild->u.Process.fCatchOutput = TRUE;
+
+    return mkWinChildPushToCareWorker(pChild, pPid);
+}
+
+/**
+ * Creates a chile process with a pipe hooked up to stdout.
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param   papszArgs       The argument vector.
+ * @param   papszEnv        The environment vector (optional).
+ * @param   fdErr           File descriptor to hook up to stderr.
+ * @param   pPid            Where to return the pid.
+ * @param   pfdReadPipe     Where to return the read end of the pipe.
+ */
+int MkWinChildCreateWithStdOutPipe(char **papszArgs, char **papszEnv, int fdErr, pid_t *pPid, int *pfdReadPipe)
+{
+    /*
+     * Create the pipe.
+     */
+    HANDLE hReadPipe;
+    HANDLE hWritePipe;
+    if (CreatePipe(&hReadPipe, &hWritePipe, NULL, 0 /* default size */))
+    {
+        //if (SetHandleInformation(hWritePipe, HANDLE_FLAG_INHERIT /* clear */ , HANDLE_FLAG_INHERIT /*set*/))
+        {
+            int fdReadPipe = _open_osfhandle((intptr_t)hReadPipe, O_RDONLY);
+            if (fdReadPipe >= 0)
+            {
+                PWINCHILD pChild;
+                int rc;
+
+                /*
+                 * Get a handle for fdErr.  Ignore failure.
+                 */
+                HANDLE hStdErr = INVALID_HANDLE_VALUE;
+                if (fdErr >= 0)
+                {
+                    HANDLE hNative = (HANDLE)_get_osfhandle(fdErr);
+                    if (!DuplicateHandle(GetCurrentProcess(), hNative, GetCurrentProcess(),
+                                         &hStdErr, 0 /*DesiredAccess*/, TRUE /*fInherit*/, DUPLICATE_SAME_ACCESS))
+                    {
+                        ONN(error, NILF, _("DuplicateHandle failed on stderr descriptor (%u): %u\n"), fdErr, GetLastError());
+                        hStdErr = INVALID_HANDLE_VALUE;
+                    }
+                }
+
+                /*
+                 * Push it off to the worker thread.
+                 */
+                pChild = mkWinChildNew(WINCHILDTYPE_PROCESS);
+                pChild->u.Process.papszArgs = mkWinChildCopyStringArray(papszArgs, &pChild->u.Process.cbArgsStrings);
+                pChild->u.Process.papszEnv  = mkWinChildCopyStringArray(papszEnv ? papszEnv : environ,
+                                                                        &pChild->u.Process.cbEnvStrings);
+                //if (pszShell)
+                //    pChild->u.Process.pszShell = xstrdup(pszShell);
+                pChild->u.Process.hStdOut   = hWritePipe;
+                pChild->u.Process.hStdErr   = hStdErr;
+                pChild->u.Process.fCloseStdErr = TRUE;
+                pChild->u.Process.fCloseStdOut = TRUE;
+
+                rc = mkWinChildPushToCareWorker(pChild, pPid);
+                if (rc == 0)
+                    *pfdReadPipe = fdReadPipe;
+                else
+                {
+                    ON(error, NILF, _("mkWinChildPushToCareWorker failed on pipe: %d\n"), rc);
+                    close(fdReadPipe);
+                    *pfdReadPipe = -1;
+                    *pPid = -1;
+                }
+                return rc;
+            }
+
+            ON(error, NILF, _("_open_osfhandle failed on pipe: %u\n"), errno);
+        }
+        //else
+        //    ON(error, NILF, _("SetHandleInformation failed on pipe: %u\n"), GetLastError());
+        if (hReadPipe != INVALID_HANDLE_VALUE)
+            CloseHandle(hReadPipe);
+        CloseHandle(hWritePipe);
+    }
+    else
+        ON(error, NILF, _("CreatePipe failed: %u\n"), GetLastError());
+    *pfdReadPipe = -1;
+    *pPid = -1;
+    return -1;
+}
+
+#ifdef KMK
+
+/**
+ * Interface used by kmkbuiltin.c for executing builtin commands on threads.
+ *
+ * @returns 0 on success, windows status code on failure.
+ * @param   pBuiltIn        The kmk built-in command entry.
+ * @param   cArgs           The number of arguments in papszArgs.
+ * @param   papszArgs       The argument vector.
+ * @param   papszEnv        The environment vector, optional.
+ * @param   pMkChild        The make child structure.
+ * @param   pPid            Where to return the pid.
+ */
+int MkWinChildCreateBuiltIn(PCKMKBUILTINENTRY pBuiltIn, int cArgs, char **papszArgs, char **papszEnv,
+                            struct child *pMkChild, pid_t *pPid)
+{
+    size_t    cbIgnored;
+    PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_BUILT_IN);
+    pChild->pMkChild            = pMkChild;
+    pChild->u.BuiltIn.pBuiltIn  = pBuiltIn;
+    pChild->u.BuiltIn.cArgs     = cArgs;
+    pChild->u.BuiltIn.papszArgs = mkWinChildCopyStringArray(papszArgs, &cbIgnored);
+    pChild->u.BuiltIn.papszEnv  = papszEnv ? mkWinChildCopyStringArray(papszEnv, &cbIgnored) : NULL;
+    return mkWinChildPushToCareWorker(pChild, pPid);
+}
+
+/**
+ * Interface used by append.c for do the slow file system part.
+ *
+ * This will append the given buffer to the specified file and free the buffer.
+ *
+ * @returns 0 on success, windows status code on failure.
+ *
+ * @param   pszFilename     The name of the file to append to.
+ * @param   ppszAppend      What to append.  The pointer pointed to is set to
+ *                          NULL once we've taken ownership of the buffer and
+ *                          promise to free it.
+ * @param   cbAppend        How much to append.
+ * @param   fTruncate       Whether to truncate the file before appending to it.
+ * @param   pMkChild        The make child structure.
+ * @param   pPid            Where to return the pid.
+ */
+int MkWinChildCreateAppend(const char *pszFilename, char **ppszAppend, size_t cbAppend, int fTruncate,
+                           struct child *pMkChild, pid_t *pPid)
+{
+    size_t    cbFilename = strlen(pszFilename) + 1;
+    PWINCHILD pChild     = mkWinChildNew(WINCHILDTYPE_APPEND);
+    pChild->pMkChild            = pMkChild;
+    pChild->u.Append.fTruncate  = fTruncate;
+    pChild->u.Append.pszAppend  = *ppszAppend;
+    pChild->u.Append.cbAppend   = cbAppend;
+    pChild->u.Append.pszFilename = (char *)memcpy(xmalloc(cbFilename), pszFilename, cbFilename);
+    *ppszAppend = NULL;
+    return mkWinChildPushToCareWorker(pChild, pPid);
+}
+
+/**
+ * Interface used by kSubmit.c for registering stuff to wait on.
+ *
+ * @returns 0 on success, windows status code on failure.
+ * @param   hEvent          The event object handle to wait on.
+ * @param   pvSubmitWorker  The argument to pass back to kSubmit to clean up.
+ * @param   pStdOut         Standard output pipe for the worker. Optional.
+ * @param   pStdErr         Standard error pipe for the worker. Optional.
+ * @param   pMkChild        The make child structure.
+ * @param   pPid            Where to return the pid.
+ */
+int MkWinChildCreateSubmit(intptr_t hEvent, void *pvSubmitWorker, PWINCCWPIPE pStdOut, PWINCCWPIPE pStdErr,
+                           struct child *pMkChild, pid_t *pPid)
+{
+    PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_SUBMIT);
+    pChild->pMkChild                = pMkChild;
+    pChild->u.Submit.hEvent         = (HANDLE)hEvent;
+    pChild->u.Submit.pvSubmitWorker = pvSubmitWorker;
+    pChild->u.Submit.pStdOut        = pStdOut;
+    pChild->u.Submit.pStdErr        = pStdErr;
+    return mkWinChildPushToCareWorker(pChild, pPid);
+}
+
+/**
+ * Interface used by redirect.c for registering stuff to wait on.
+ *
+ * @returns 0 on success, windows status code on failure.
+ * @param   hProcess        The process object to wait on.
+ * @param   pPid            Where to return the pid.
+ */
+int MkWinChildCreateRedirect(intptr_t hProcess, pid_t *pPid)
+{
+    PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_REDIRECT);
+    pChild->u.Redirect.hProcess = (HANDLE)hProcess;
+    return mkWinChildPushToCareWorker(pChild, pPid);
+}
+
+
+/**
+ * New interface used by redirect.c for spawning and waitin on a child.
+ *
+ * This interface is only used when kmk_builtin_redirect is already running on
+ * a worker thread.
+ *
+ * @returns exit status.
+ * @param   pvWorker        The worker instance.
+ * @param   pszExecutable   The executable image to run.
+ * @param   papszArgs       Argument vector.
+ * @param   fQuotedArgv     Whether the argument vector is already quoted and
+ *                          just need some space to be turned into a command
+ *                          line.
+ * @param   papszEnvVars    Environment vector.
+ * @param   pszCwd          The working directory of the child.  Optional.
+ * @param   pafReplace      Which standard handles to replace. Maybe modified!
+ * @param   pahReplace      The replacement handles.  Maybe modified!
+ *
+ */
+int MkWinChildBuiltInExecChild(void *pvWorker, const char *pszExecutable, char **papszArgs, BOOL fQuotedArgv,
+                               char **papszEnvVars, const char *pszCwd, BOOL pafReplace[3], HANDLE pahReplace[3])
+{
+    PWINCHILDCAREWORKER pWorker = (PWINCHILDCAREWORKER)pvWorker;
+    WCHAR              *pwszSearchPath   = NULL;
+    WCHAR              *pwszzEnvironment = NULL;
+    WCHAR              *pwszCommandLine  = NULL;
+    WCHAR              *pwszImageName    = NULL;
+    WCHAR              *pwszCwd          = NULL;
+    BOOL                fNeedShell       = FALSE;
+    PWINCHILD           pChild;
+    int                 rc;
+    assert(pWorker->uMagic == WINCHILDCAREWORKER_MAGIC);
+    pChild = pWorker->pCurChild;
+    assert(pChild != NULL && pChild->uMagic == WINCHILD_MAGIC);
+
+    /*
+     * Convert the CWD first since it's optional and we don't need to clean
+     * up anything here if it fails.
+     */
+    if (pszCwd)
+    {
+        size_t cchCwd = strlen(pszCwd);
+        int    cwcCwd = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszCwd, cchCwd + 1, NULL, 0);
+        pwszCwd = xmalloc((cwcCwd + 1) * sizeof(WCHAR)); /* (+1 in case cwcCwd is 0) */
+        cwcCwd = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszCwd, cchCwd + 1, pwszCwd, cwcCwd + 1);
+        if (!cwcCwd)
+        {
+            rc = GetLastError();
+            MkWinChildError(pWorker, 1, _("MultiByteToWideChar failed to convert CWD (%s): %u\n"), pszCwd, (unsigned)rc);
+            return rc;
+        }
+    }
+
+    /*
+     * Before we search for the image, we convert the environment so we don't
+     * have to traverse it twice to find the PATH.
+     */
+    rc = mkWinChildcareWorkerConvertEnvironment(pWorker, papszEnvVars ? papszEnvVars : environ, 0/*cbEnvStrings*/,
+                                                &pwszzEnvironment, &pwszSearchPath);
+    /*
+     * Find the executable and maybe checking if it's a shell script, then
+     * convert it to a command line.
+     */
+    if (rc == 0)
+        rc = mkWinChildcareWorkerFindImage(pWorker, pszExecutable, pwszSearchPath, pwszzEnvironment, NULL /*pszShell*/,
+                                           &pwszImageName, &fNeedShell, &pChild->fProbableClExe);
+    if (rc == 0)
+    {
+        assert(!fNeedShell);
+        if (!fQuotedArgv)
+            rc = mkWinChildcareWorkerConvertCommandline(pWorker, papszArgs, 0 /*fFlags*/, &pwszCommandLine);
+        else
+            rc = mkWinChildcareWorkerConvertQuotedArgvToCommandline(pWorker, papszArgs, &pwszCommandLine);
+
+        /*
+         * Create the child process.
+         */
+        if (rc == 0)
+        {
+            HANDLE hProcess;
+            rc = mkWinChildcareWorkerCreateProcess(pWorker, pwszImageName, pwszCommandLine, pwszzEnvironment,
+                                                   pwszCwd, pafReplace, pahReplace, TRUE /*fCatchOutput*/, &hProcess);
+            if (rc == 0)
+            {
+                /*
+                 * Wait for the child to complete.
+                 */
+                rc = mkWinChildcareWorkerWaitForProcess(pWorker, pChild, hProcess, pwszImageName, TRUE /*fCatchOutput*/);
+                CloseHandle(hProcess);
+            }
+        }
+    }
+
+    free(pwszCwd);
+    free(pwszCommandLine);
+    free(pwszImageName);
+    free(pwszzEnvironment);
+
+    return rc;
+}
+
+#endif /* CONFIG_NEW_WIN_CHILDREN */
+
+/**
+ * Interface used to kill process when processing Ctrl-C and fatal errors.
+ *
+ * @returns 0 on success, -1 & errno on error.
+ * @param   pid                 The process to kill (PWINCHILD).
+ * @param   iSignal             What to kill it with.
+ * @param   pMkChild            The make child structure for validation.
+ */
+int MkWinChildKill(pid_t pid, int iSignal, struct child *pMkChild)
+{
+    PWINCHILD pChild = (PWINCHILD)pid;
+    if (pChild)
+    {
+        assert(pChild->uMagic == WINCHILD_MAGIC);
+        if (pChild->uMagic == WINCHILD_MAGIC)
+        {
+            switch (pChild->enmType)
+            {
+                case WINCHILDTYPE_PROCESS:
+                    assert(pChild->pMkChild == pMkChild);
+                    TerminateProcess(pChild->u.Process.hProcess, DBG_TERMINATE_PROCESS);
+                    pChild->iSignal = iSignal;
+                    break;
+#ifdef KMK
+                case WINCHILDTYPE_SUBMIT:
+                {
+                    pChild->iSignal = iSignal;
+                    SetEvent(pChild->u.Submit.hEvent);
+                    break;
+                }
+
+                case WINCHILDTYPE_REDIRECT:
+                    TerminateProcess(pChild->u.Redirect.hProcess, DBG_TERMINATE_PROCESS);
+                    pChild->iSignal = iSignal;
+                    break;
+
+                case WINCHILDTYPE_BUILT_IN:
+                    break;
+
+#endif /* KMK */
+                default:
+                    assert(0);
+            }
+        }
+    }
+    return -1;
+}
+
+/**
+ * Wait for a child process to complete
+ *
+ * @returns 0 on success, windows error code on failure.
+ * @param   fBlock          Whether to block.
+ * @param   pPid            Where to return the pid if a child process
+ *                          completed.  This is set to zero if none.
+ * @param   piExitCode      Where to return the exit code.
+ * @param   piSignal        Where to return the exit signal number.
+ * @param   pfCoreDumped    Where to return the core dumped indicator.
+ * @param   ppMkChild       Where to return the associated struct child pointer.
+ */
+int MkWinChildWait(int fBlock, pid_t *pPid, int *piExitCode, int *piSignal, int *pfCoreDumped, struct child **ppMkChild)
+{
+    PWINCHILD pChild;
+
+    *pPid         = 0;
+    *piExitCode   = -222222;
+    *pfCoreDumped = 0;
+    *ppMkChild    = NULL;
+
+    /*
+     * Wait if necessary.
+     */
+    if (fBlock && !g_pTailCompletedChildren && g_cPendingChildren > 0)
+    {
+        DWORD dwStatus = WaitForSingleObject(g_hEvtWaitChildren, INFINITE);
+        if (dwStatus == WAIT_FAILED)
+            return (int)GetLastError();
+    }
+
+    /*
+     * Try unlink the last child in the LIFO.
+     */
+    pChild = g_pTailCompletedChildren;
+    if (!pChild)
+        return 0;
+    pChild = mkWinChildDequeFromLifo(&g_pTailCompletedChildren, pChild);
+    assert(pChild);
+
+    /*
+     * Set return values and ditch the child structure.
+     */
+    *pPid         = pChild->pid;
+    *piExitCode   = pChild->iExitCode;
+    *pfCoreDumped = pChild->fCoreDumped;
+    *ppMkChild    = pChild->pMkChild;
+    switch (pChild->enmType)
+    {
+        case WINCHILDTYPE_PROCESS:
+            break;
+#ifdef KMK
+        case WINCHILDTYPE_BUILT_IN:
+        case WINCHILDTYPE_APPEND:
+        case WINCHILDTYPE_SUBMIT:
+        case WINCHILDTYPE_REDIRECT:
+            break;
+#endif /* KMK */
+        default:
+            assert(0);
+    }
+    mkWinChildDelete(pChild);
+
+#ifdef KMK
+    /* Flush the volatile directory cache. */
+    dir_cache_invalid_after_job();
+#endif
+    return 0;
+}
+
+/**
+ * Get the child completed event handle.
+ *
+ * Needed when w32os.c is waiting for a job token to become available, given
+ * that completed children is the typical source of these tokens (esp. for kmk).
+ *
+ * @returns Zero if no active children, event handle if waiting is required.
+ */
+intptr_t MkWinChildGetCompleteEventHandle(void)
+{
+    /* We don't return the handle if we've got completed children.  This
+       is a safe guard against being called twice in a row without any
+       MkWinChildWait call inbetween. */
+    if (!g_pTailCompletedChildren)
+        return (intptr_t)g_hEvtWaitChildren;
+    return 0;
+}
+
+/**
+ * Emulate execv() for restarting kmk after one or more makefiles has been made.
+ *
+ * Does not return.
+ *
+ * @param   papszArgs           The arguments.
+ * @param   papszEnv            The environment.
+ */
+void MkWinChildReExecMake(char **papszArgs, char **papszEnv)
+{
+    PROCESS_INFORMATION     ProcInfo;
+    STARTUPINFOW            StartupInfo;
+    WCHAR                  *pwszCommandLine;
+    WCHAR                  *pwszzEnvironment;
+    WCHAR                  *pwszPathIgnored;
+    int                     rc;
+
+    /*
+     * Get the executable name.
+     */
+    WCHAR wszImageName[MKWINCHILD_MAX_PATH];
+    DWORD cwcImageName = GetModuleFileNameW(GetModuleHandle(NULL), wszImageName, MKWINCHILD_MAX_PATH);
+    if (cwcImageName == 0)
+        ON(fatal, NILF, _("MkWinChildReExecMake: GetModuleFileName failed: %u\n"), GetLastError());
+
+    /*
+     * Create the command line and environment.
+     */
+    rc = mkWinChildcareWorkerConvertCommandline(NULL, papszArgs, 0 /*fFlags*/, &pwszCommandLine);
+    if (rc != 0)
+        ON(fatal, NILF, _("MkWinChildReExecMake: mkWinChildcareWorkerConvertCommandline failed: %u\n"), rc);
+
+    rc = mkWinChildcareWorkerConvertEnvironment(NULL, papszEnv ? papszEnv : environ, 0 /*cbEnvStrings*/,
+                                                &pwszzEnvironment, &pwszPathIgnored);
+    if (rc != 0)
+        ON(fatal, NILF, _("MkWinChildReExecMake: mkWinChildcareWorkerConvertEnvironment failed: %u\n"), rc);
+
+#ifdef KMK
+    /*
+     * Flush the file system cache to avoid messing up tools fetching
+     * going on in the "exec'ed" make by keeping directories open.
+     */
+    dir_cache_invalid_all_and_close_dirs(1);
+#endif
+
+    /*
+     * Fill out the startup info and try create the process.
+     */
+    memset(&ProcInfo, 0, sizeof(ProcInfo));
+    memset(&StartupInfo, 0, sizeof(StartupInfo));
+    StartupInfo.cb = sizeof(StartupInfo);
+    GetStartupInfoW(&StartupInfo);
+    if (!CreateProcessW(wszImageName, pwszCommandLine, NULL /*pProcSecAttr*/, NULL /*pThreadSecAttr*/,
+                        TRUE /*fInheritHandles*/, CREATE_UNICODE_ENVIRONMENT, pwszzEnvironment, NULL /*pwsz*/,
+                        &StartupInfo, &ProcInfo))
+        ON(fatal, NILF, _("MkWinChildReExecMake: CreateProcessW failed: %u\n"), GetLastError());
+    CloseHandle(ProcInfo.hThread);
+
+    /*
+     * Wait for it to complete and forward the status code to our parent.
+     */
+    for (;;)
+    {
+        DWORD dwExitCode = -2222;
+        DWORD dwStatus = WaitForSingleObject(ProcInfo.hProcess, INFINITE);
+        if (   dwStatus == WAIT_IO_COMPLETION
+            || dwStatus == WAIT_TIMEOUT /* whatever */)
+            continue; /* however unlikely, these aren't fatal. */
+
+        /* Get the status code and terminate. */
+        if (dwStatus == WAIT_OBJECT_0)
+        {
+            if (!GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
+            {
+                ON(fatal, NILF, _("MkWinChildReExecMake: GetExitCodeProcess failed: %u\n"), GetLastError());
+                dwExitCode = -2222;
+            }
+        }
+        else if (dwStatus)
+            dwExitCode = dwStatus;
+
+        CloseHandle(ProcInfo.hProcess);
+        for (;;)
+            exit(dwExitCode);
+    }
+}
+
+#ifdef WITH_RW_LOCK
+/** Serialization with kmkbuiltin_redirect. */
+void MkWinChildExclusiveAcquire(void)
+{
+    AcquireSRWLockExclusive(&g_RWLock);
+}
+
+/** Serialization with kmkbuiltin_redirect. */
+void MkWinChildExclusiveRelease(void)
+{
+    ReleaseSRWLockExclusive(&g_RWLock);
+}
+#endif /* WITH_RW_LOCK */
+
+/**
+ * Implementation of the CLOSE_ON_EXEC macro.
+ *
+ * @returns errno value.
+ * @param   fd          The file descriptor to hide from children.
+ */
+int MkWinChildUnrelatedCloseOnExec(int fd)
+{
+    if (fd >= 0)
+    {
+        HANDLE hNative = (HANDLE)_get_osfhandle(fd);
+        if (hNative != INVALID_HANDLE_VALUE && hNative != NULL)
+        {
+            if (SetHandleInformation(hNative, HANDLE_FLAG_INHERIT /*clear*/ , 0 /*set*/))
+                return 0;
+        }
+        return errno;
+    }
+    return EINVAL;
+}
+
diff --git a/src/kmk/w32/winchildren.h b/src/kmk/w32/winchildren.h
new file mode 100644
index 0000000..e70bd1e
--- /dev/null
+++ b/src/kmk/w32/winchildren.h
@@ -0,0 +1,115 @@
+/* $Id: winchildren.h 3313 2020-03-16 02:31:38Z bird $ */
+/** @file
+ * Child process creation and management for kmk.
+ */
+
+/*
+ * Copyright (c) 2018 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ *
+ * This file is part of kBuild.
+ *
+ * kBuild is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * kBuild is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with kBuild.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+#ifndef INCLUDED_WINCHILDREN_H
+#define INCLUDED_WINCHILDREN_H
+
+/** Child processor group allocator state. */
+typedef struct MKWINCHILDCPUGROUPALLOCSTATE
+{
+    /** The group index for the worker allocator.
+     * This is ever increasing and must be modded by g_cProcessorGroups. */
+    unsigned int    idxGroup;
+    /** The processor in group index for the worker allocator. */
+    unsigned int    idxProcessorInGroup;
+} MKWINCHILDCPUGROUPALLOCSTATE;
+/** Pointer to a CPU group allocator state.   */
+typedef MKWINCHILDCPUGROUPALLOCSTATE *PMKWINCHILDCPUGROUPALLOCSTATE;
+
+#ifdef DECLARE_HANDLE
+/**
+ * A childcare worker pipe.
+ */
+typedef struct WINCCWPIPE
+{
+    /** My end of the pipe. */
+    HANDLE              hPipeMine;
+    /** The child end of the pipe. */
+    HANDLE              hPipeChild;
+    /** The event for asynchronous reading. */
+    HANDLE              hEvent;
+    /** Which pipe this is (1 == stdout, 2 == stderr). */
+    unsigned char       iWhich;
+    /** Set if we've got a read pending already. */
+    BOOL                fReadPending;
+    /** Indicator that we've written out something.  This is cleared before
+     * we start catching output from a new child and use in the CL.exe
+     * supression heuristics. */
+    BOOL                fHaveWrittenOut;
+    /** Number of bytes at the start of the buffer that we've already
+     * written out.  We try write out whole lines. */
+    DWORD               cbWritten;
+    /** The buffer offset of the read currently pending. */
+    DWORD               offPendingRead;
+    /** Read buffer size. */
+    DWORD               cbBuffer;
+    /** The read buffer allocation. */
+    unsigned char      *pbBuffer;
+    /** Overlapped I/O structure. */
+    OVERLAPPED          Overlapped;
+} WINCCWPIPE;
+#endif
+
+typedef struct WINCCWPIPE *PWINCCWPIPE;
+
+void    MkWinChildInit(unsigned int cJobSlot);
+void    MkWinChildReExecMake(char **papszArgs, char **papszEnv);
+intptr_t MkWinChildGetCompleteEventHandle(void);
+int     MkWinChildCreate(char **papszArgs, char **papszEnv, const char *pszShell, struct child *pMkChild, pid_t *pPid);
+int     MkWinChildCreateWithStdOutPipe(char **papszArgs, char **papszEnv, int fdErr, pid_t *pPid, int *pfdReadPipe);
+void    MkWinChildInitCpuGroupAllocator(PMKWINCHILDCPUGROUPALLOCSTATE pState);
+unsigned int MkWinChildAllocateCpuGroup(PMKWINCHILDCPUGROUPALLOCSTATE pState);
+
+#ifdef KMK
+struct KMKBUILTINENTRY;
+int     MkWinChildCreateBuiltIn(struct KMKBUILTINENTRY const *pBuiltIn, int cArgs, char **papszArgs,
+                                char **papszEnv, struct child *pMkChild, pid_t *pPid);
+int     MkWinChildCreateAppend(const char *pszFilename, char **ppszAppend, size_t cbAppend, int fTruncate,
+                               struct child *pMkChild, pid_t *pPid);
+
+int     MkWinChildCreateSubmit(intptr_t hEvent, void *pvSubmitWorker, PWINCCWPIPE pStdOut, PWINCCWPIPE pStdErr,
+                               struct child *pMkChild, pid_t *pPid);
+PWINCCWPIPE MkWinChildcareCreateWorkerPipe(unsigned iWhich, unsigned int idxWorker);
+void    MkWinChildcareWorkerDrainPipes(struct WINCHILD *pChild, PWINCCWPIPE pStdOut, PWINCCWPIPE pStdErr);
+void    MkWinChildcareDeleteWorkerPipe(PWINCCWPIPE pPipe);
+
+int     MkWinChildCreateRedirect(intptr_t hProcess, pid_t *pPid);
+# ifdef DECLARE_HANDLE
+int     MkWinChildBuiltInExecChild(void *pvWorker, const char *pszExecutable, char **papszArgs, BOOL fQuotedArgv,
+                                   char **papszEnvVars, const char *pszCwd, BOOL pafReplace[3], HANDLE pahReplace[3]);
+# endif
+#endif /* KMK */
+int     MkWinChildKill(pid_t pid, int iSignal, struct child *pMkChild);
+int     MkWinChildWait(int fBlock, pid_t *pPid, int *piExitCode, int *piSignal, int *pfCoreDumped, struct child **ppMkChild);
+void    MkWinChildExclusiveAcquire(void);
+void    MkWinChildExclusiveRelease(void);
+
+#undef  CLOSE_ON_EXEC
+#define CLOSE_ON_EXEC(a_fd) MkWinChildUnrelatedCloseOnExec(a_fd)
+int     MkWinChildUnrelatedCloseOnExec(int fd);
+
+
+#endif
+