Support Linux binfmt_misc and APE loading on Apple

The "no modify self" variant of Actually Portable Executable is now
supported on all platforms. If you use `$(APE_NO_MODIFY_SELF)` then
ld.bfd will embed a 4096 byte ELF binary and a 4096 byte Macho file
which are installed on the fly to ${TMPDIR:-/tmp}, which enables us
launch the executable, without needing to copy the whole executable

To prevent it from copying a tiny executable to your temp directory
you need to install the `ape` command (renamed from ape-loader), to
a system path. For example:

    # FreeBSD / NetBSD / OpenBSD
    make -j8 o//ape/ape
    cp o//ape/ape /usr/bin/ape

    # Mac OS
    # make -j8 o//ape/ape.macho
    curl https://justine.lol/ape.macho >/usr/bin/ape
    chmod +x /usr/bin/ape

On Linux you can get even more performance with the new binfmt_misc
support which makes launching non-modifying APE binaries as fast as
launching ELF executables. Running the following command:

    # Linux
    ape/apeinstall.sh

Will copy APE loader to /usr/bin/ape and register with binfmt_misc
Lastly, this change also fixes a really interesting race condition
with OpenBSD thread joining.

third_party/make/config.h

@@ -620,7 +620,7 @@
 /* #undef HAVE__SET_INVALID_PARAMETER_HANDLER */
 
 /* Build host information. */
-#define MAKE_HOST "x86_64-pc-linux-gnu"
+#define MAKE_HOST "x86_64-pc-cosmopolitan"
 
 /* Define to 1 to enable job server support in GNU make. */
 /* TODO(jart): make it work */

third_party/make/dir.c

@@ -689,15 +689,9 @@ void print_dir_data_base(void) {
       if (dir->contents == 0)
         printf(_("# %s: could not be stat'd.\n"), dir->name);
       else if (dir->contents->dirfiles.ht_vec == 0) {
-#ifdef WINDOWS32
-        printf(_("# %s (key %s, mtime %I64u): could not be opened.\n"),
-               dir->name, dir->contents->path_key,
-               (unsigned long long)dir->contents->mtime);
-#else /* WINDOWS32 */
         printf(_("# %s (device %ld, inode %ld): could not be opened.\n"),
                dir->name, (long int)dir->contents->dev,
                (long int)dir->contents->ino);
-#endif /* WINDOWS32 */
       } else {
         unsigned int f = 0;
         unsigned int im = 0;
@@ -715,14 +709,8 @@ void print_dir_data_base(void) {
               ++f;
           }
         }
-#ifdef WINDOWS32
-        printf(_("# %s (key %s, mtime %I64u): "), dir->name,
-               dir->contents->path_key,
-               (unsigned long long)dir->contents->mtime);
-#else /* WINDOWS32 */
         printf(_("# %s (device %ld, inode %ld): "), dir->name,
                (long)dir->contents->dev, (long)dir->contents->ino);
-#endif /* WINDOWS32 */
         if (f == 0)
           fputs(_("No"), stdout);
         else
@@ -822,9 +810,7 @@ static struct dirent *read_dirstream(__ptr_t stream) {
 #ifdef _DIRENT_HAVE_D_NAMLEN
       d->d_namlen = len - 1;
 #endif
-#ifdef HAVE_STRUCT_DIRENT_D_TYPE
       d->d_type = df->type;
-#endif
       memcpy(d->d_name, df->name, len);
       return d;
     }

third_party/smallz4/smallz4.hh

@@ -1,5 +1,6 @@
 #ifndef COSMOPOLITAN_THIRD_PARTY_SMALLZ4_SMALLZ4_H_
 #define COSMOPOLITAN_THIRD_PARTY_SMALLZ4_SMALLZ4_H_
+#include "libc/bits/bits.h"
 #include "third_party/libcxx/vector"
 
 /**
@@ -138,7 +139,7 @@ class smallz4 {
 
   /// return true, if the four bytes at *a and *b match
   inline static bool match4(const void* const a, const void* const b) {
-    return *(const uint32_t*)a == *(const uint32_t*)b;
+    return READ32LE(a) == READ32LE(b);
   }
 
   /// simple hash function, input: 32 bits, output: HashBits bits (by default:
@@ -636,7 +637,7 @@ class smallz4 {
         }
 
         // read next four bytes
-        const uint32_t four = *(uint32_t*)(dataBlock + i);
+        const uint32_t four = READ32LE(dataBlock + i);
         // convert to a shorter hash
         const uint32_t hash = getHash32(four);
 
@@ -674,10 +675,9 @@ class smallz4 {
         // check the hash chain
         while (true) {
           // read four bytes
-          currentFour =
-              *(uint32_t*)(&data[lastHashMatch -
-                                 dataZero]);  // match may be found in the
-                                              // previous block, too
+          currentFour = READ32LE(
+              &data[lastHashMatch - dataZero]);  // match may be found in the
+                                                 // previous block, too
           // match chain found, first 4 bytes are identical
           if (currentFour == four) break;