Restart CI for New Technology and UBSAN hunting

Continuous Integration (via runit and runitd) is now re-enabled on win7
and win10. The `make test` command, which runs the tests on all systems
is now the fastest and most stable it's been since the project started.

UBSAN is now enabled in MODE=dbg in addition to ASAN. Many instances of
undefined behavior have been removed. Mostly things like passing a NULL
argument to memcpy(), which works fine with Cosmopolitan Libc, but that
doesn't prevents the compiler from being unhappy. There was an issue w/
GNU make where static analysis claims a sprintf() call can overflow. We
also now have nicer looking crash reports on Windows since uname should
now be supported and msys64 addr2line works reliably.

libc/calls/gethostname-nt.c

@@ -22,11 +22,11 @@
 #include "libc/nt/systeminfo.h"
 #include "libc/str/str.h"
 
-textwindows int gethostname_nt(char *name, size_t len) {
+textwindows int gethostname_nt(char *name, size_t len, int kind) {
   uint32_t nSize;
   char16_t name16[256];
   nSize = ARRAYLEN(name16);
-  if (GetComputerNameEx(kNtComputerNamePhysicalDnsHostname, name16, &nSize)) {
+  if (GetComputerNameEx(kind, name16, &nSize)) {
     tprecode16to8(name, len, name16);
     return 0;
   } else {

libc/calls/gethostname.c

@@ -19,6 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/dce.h"
+#include "libc/nt/enum/computernameformat.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -37,6 +38,6 @@ int gethostname(char *name, size_t len) {
       return gethostname_bsd(name, len);
     }
   } else {
-    return gethostname_nt(name, len);
+    return gethostname_nt(name, len, kNtComputerNamePhysicalDnsHostname);
   }
 }

libc/calls/internal.h

@@ -234,7 +234,7 @@ void __sigenter_xnu(void *, i32, i32, struct __darwin_siginfo *,
                     struct __darwin_ucontext *) hidden;
 int gethostname_linux(char *, size_t) hidden;
 int gethostname_bsd(char *, size_t) hidden;
-int gethostname_nt(char *, size_t) hidden;
+int gethostname_nt(char *, size_t, int) hidden;
 size_t __iovec_size(const struct iovec *, size_t) hidden;
 void __rusage2linux(struct rusage *) hidden;
 int __notziposat(int, const char *);

libc/calls/ntcontext2linux.c

@@ -24,6 +24,7 @@
 textwindows void ntcontext2linux(ucontext_t *ctx, const struct NtContext *cr) {
   if (!cr) return;
   ctx->uc_flags = cr->EFlags;
+  ctx->uc_mcontext.gregs[REG_EFL] = cr->EFlags;
   ctx->uc_mcontext.rax = cr->Rax;
   ctx->uc_mcontext.rbx = cr->Rbx;
   ctx->uc_mcontext.rcx = cr->Rcx;

libc/calls/uname.c

@@ -18,34 +18,72 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/calls/struct/utsname.h"
+#include "libc/dce.h"
+#include "libc/fmt/itoa.h"
+#include "libc/intrin/asan.internal.h"
+#include "libc/nt/enum/computernameformat.h"
+#include "libc/nt/struct/teb.h"
+#include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
+#include "libc/sysv/errfuns.h"
+
+static inline textwindows noasan int NtGetMajorVersion(void) {
+  return NtGetPeb()->OSMajorVersion;
+}
+
+static inline textwindows noasan int NtGetMinorVersion(void) {
+  return NtGetPeb()->OSMinorVersion;
+}
+
+static inline textwindows noasan int NtGetBuildNumber(void) {
+  return NtGetPeb()->OSBuildNumber;
+}
 
 /**
  * Asks kernel to give us the `uname -a` data.
  * @return 0 on success, or -1 w/ errno
  */
 int uname(struct utsname *lool) {
-  char *out;
+  int rc, v;
+  char *out, *p;
   size_t i, j, len;
   char tmp[sizeof(struct utsname)];
-  bzero(tmp, sizeof(tmp));
-  if (sys_uname(tmp) != -1) {
-    out = (char *)lool;
-    i = 0;
-    j = 0;
-    for (;;) {
-      len = strlen(&tmp[j]);
-      if (len >= sizeof(struct utsname) - i) break;
-      memcpy(&out[i], &tmp[j], len + 1);
-      i += SYS_NMLN;
-      j += len;
-      while (j < sizeof(tmp) && tmp[j] == '\0') ++j;
-      if (j == sizeof(tmp)) break;
-    }
-    return 0;
+  if (!lool) return efault();
+  if (!lool || (IsAsan() && !__asan_is_valid(lool, sizeof(*lool)))) {
+    rc = efault();
   } else {
-    bzero(lool, sizeof(struct utsname));
-    return -1;
+    bzero(tmp, sizeof(tmp));
+    if (!IsWindows()) {
+      if ((rc = sys_uname(tmp)) != -1) {
+        out = (char *)lool;
+        for (i = j = 0;;) {
+          len = strlen(&tmp[j]);
+          if (len >= sizeof(struct utsname) - i) break;
+          memcpy(&out[i], &tmp[j], len + 1);
+          i += SYS_NMLN;
+          j += len;
+          while (j < sizeof(tmp) && tmp[j] == '\0') ++j;
+          if (j == sizeof(tmp)) break;
+        }
+      }
+    } else {
+      v = NtGetVersion();
+      p = lool->version;
+      p = FormatUint32(p, NtGetMajorVersion()), *p++ = '.';
+      p = FormatUint32(p, NtGetMinorVersion()), *p++ = '-';
+      p = FormatUint32(p, NtGetBuildNumber());
+      strcpy(lool->sysname, "The New Technology");
+      strcpy(lool->machine, "x86_64");
+      rc = gethostname_nt(lool->nodename, sizeof(lool->nodename),
+                          kNtComputerNamePhysicalDnsHostname);
+      rc |= gethostname_nt(lool->domainname, sizeof(lool->domainname),
+                           kNtComputerNamePhysicalDnsDomain);
+    }
   }
+  STRACE("uname([%s, %s, %s, %s, %s, %s]) → %d% m", lool->sysname,
+         lool->nodename, lool->release, lool->version, lool->machine,
+         lool->domainname, rc);
+  return rc;
 }

libc/calls/wincrash.c

@@ -24,9 +24,10 @@
 #include "libc/nt/enum/signal.h"
 #include "libc/nt/struct/ntexceptionpointers.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/sicode.h"
 
 textwindows unsigned __wincrash(struct NtExceptionPointers *ep) {
-  int sig, rva;
+  int sig, rva, code;
   struct Goodies {
     ucontext_t ctx;
     struct siginfo si;
@@ -34,44 +35,69 @@ textwindows unsigned __wincrash(struct NtExceptionPointers *ep) {
   STRACE("__wincrash");
   switch (ep->ExceptionRecord->ExceptionCode) {
     case kNtSignalBreakpoint:
+      code = TRAP_BRKPT;
       sig = SIGTRAP;
       break;
     case kNtSignalIllegalInstruction:
+      code = ILL_ILLOPC;
+      sig = SIGILL;
+      break;
     case kNtSignalPrivInstruction:
+      code = ILL_PRVOPC;
       sig = SIGILL;
       break;
     case kNtSignalGuardPage:
-    case kNtSignalAccessViolation:
     case kNtSignalInPageError:
+      code = SEGV_MAPERR;
+      sig = SIGSEGV;
+      break;
+    case kNtSignalAccessViolation:
+      code = SEGV_ACCERR;
       sig = SIGSEGV;
       break;
     case kNtSignalInvalidHandle:
     case kNtSignalInvalidParameter:
     case kNtSignalAssertionFailure:
+      code = SI_USER;
       sig = SIGABRT;
       break;
-    case kNtSignalFltDenormalOperand:
     case kNtSignalFltDivideByZero:
-    case kNtSignalFltInexactResult:
-    case kNtSignalFltInvalidOperation:
+      code = FPE_FLTDIV;
+      sig = SIGFPE;
+      break;
     case kNtSignalFltOverflow:
-    case kNtSignalFltStackCheck:
+      code = FPE_FLTOVF;
+      sig = SIGFPE;
+      break;
     case kNtSignalFltUnderflow:
+      code = FPE_FLTUND;
+      sig = SIGFPE;
+      break;
+    case kNtSignalFltInexactResult:
+      code = FPE_FLTRES;
+      sig = SIGFPE;
+      break;
+    case kNtSignalFltDenormalOperand:
+    case kNtSignalFltInvalidOperation:
+    case kNtSignalFltStackCheck:
     case kNtSignalIntegerDivideByZero:
     case kNtSignalFloatMultipleFaults:
     case kNtSignalFloatMultipleTraps:
+      code = FPE_FLTINV;
       sig = SIGFPE;
       break;
     case kNtSignalDllNotFound:
     case kNtSignalOrdinalNotFound:
     case kNtSignalEntrypointNotFound:
     case kNtSignalDllInitFailed:
+      code = SI_KERNEL;
       sig = SIGSYS;
       break;
     default:
       return kNtExceptionContinueSearch;
   }
   bzero(&g, sizeof(g));
+  g.si.si_code = code;
   rva = __sighandrvas[sig];
   if (rva >= kSigactionMinRva) {
     ntcontext2linux(&g.ctx, ep->ContextRecord);