Update musl to v1.2.2

The changes here mostly come from running the update_musl.py script
against the following commit:

https://github.com/emscripten-core/musl/tree/merge_v1.2.2

Notes:

- `weak` is defined in musl-internal headers so some of our usage of
  `__attribute__((weak))` was switched to `__weak__` (which is a
  synonym).

- Quite a few changes needed in library_pthread.js due to changes to
  the internal representation of __pthread struct in C.
  - removal of emscripten-specific threadStatus field.  This can
    can be fully replaced with the updated `detach_state` that
    was added to musl (along with enum values for states!) along
    with the existing `cancel` bit.
  - `attr` is no longer stored on `__pthread`; it was only duplicating
    other fields anyway.  We now include `pthread_getattr_np.c` which
    can pull those field out on demand into at attr structure.

Author: sbc100

src/library.js

@@ -677,9 +677,9 @@ LibraryManager.library = {
   __localtime_r: 'localtime_r',
 
   // musl-internal function used to implement both `asctime` and `asctime_r`
-  __asctime__deps: ['mktime'],
-  __asctime__sig: 'iii',
-  __asctime: function(tmPtr, buf) {
+  __asctime_r__deps: ['mktime'],
+  __asctime_r__sig: 'iii',
+  __asctime_r: function(tmPtr, buf) {
     var date = {
       tm_sec: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_sec, 'i32') }}},
       tm_min: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_min, 'i32') }}},
@@ -707,11 +707,11 @@ LibraryManager.library = {
     return buf;
   },
 
-  ctime_r__deps: ['localtime_r', '__asctime'],
+  ctime_r__deps: ['localtime_r', '__asctime_r'],
   ctime_r__sig: 'iii',
   ctime_r: function(time, buf) {
     var stack = stackSave();
-    var rv = ___asctime(_localtime_r(time, stackAlloc({{{ C_STRUCTS.tm.__size__ }}})), buf);
+    var rv = ___asctime_r(_localtime_r(time, stackAlloc({{{ C_STRUCTS.tm.__size__ }}})), buf);
     stackRestore(stack);
     return rv;
   },

src/library_pthread.js

@@ -189,9 +189,15 @@ var LibraryPThread = {
       Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2, exitCode);
       // When we publish this, the main thread is free to deallocate the thread object and we are done.
       // Therefore set _pthread_self = 0; above to 'release' the object in this worker thread.
-      Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 1); // Mark the thread as no longer running.
-
-      _emscripten_futex_wake(tb + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}}); // wake all threads
+      // Mark the thread as no longer running.
+      var detach_state = Atomics.load(HEAPU32, (tb + {{{ C_STRUCTS.pthread.detach_state }}} ) >> 2);
+      if (detach_state == {{{ cDefine('DT_DETACHED') }}}) {
+        PThread.setDetachState(tb, {{{ cDefine('DT_EXITED') }}});
+      } else {
+        PThread.setDetachState(tb, {{{ cDefine('DT_EXITING') }}});
+        // wake any threads that might be waiting for us to exit
+        _emscripten_futex_wake(tb + {{{ C_STRUCTS.pthread.detach_state }}}, {{{ cDefine('INT_MAX') }}});
+      }
 
       // Not hosting a pthread anymore in this worker, reset the info structures to null.
       __emscripten_thread_init(0, 0, 0); // Unregister the thread block inside the wasm module.
@@ -219,6 +225,36 @@ var LibraryPThread = {
       }
     },
 
+#if ASSERTIONS
+    detachStateToString: function(state) {
+      if (state === {{{ cDefine('DT_EXITED') }}}) return 'DT_EXITED';
+      if (state === {{{ cDefine('DT_EXITING') }}}) return 'DT_EXITING';
+      if (state === {{{ cDefine('DT_JOINABLE') }}}) return 'DT_JOINABLE';
+      if (state === {{{ cDefine('DT_DETACHED') }}}) return 'DT_DETACHED';
+      assert(false);
+    },
+#endif
+
+    setDetachState: function(thread, newstate) {
+#if PTHREADS_DEBUG
+      var oldstate = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}}) >> 2);
+      var oldname = PThread.detachStateToString(oldstate);
+      var newname = PThread.detachStateToString(newstate);
+      console.log('thread 0x' + thread.toString(16) + ' state change: ' + oldname + ' -> ' + newname);
+#endif
+      Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}}) >> 2, newstate);
+    },
+
+    swapDetachState: function(thread, oldstate, newstate) {
+#if PTHREADS_DEBUG
+      var oldstate = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}}) >> 2);
+      var oldname = PThread.detachStateToString(oldstate);
+      var newname = PThread.detachStateToString(newstate);
+      console.log('thread 0x' + thread.toString(16) + ' state change (swap): ' + oldname + ' -> ' + newname);
+#endif
+      return Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}} ) >> 2, oldstate, newstate);
+    },
+
     threadCancel: function() {
       PThread.runExitHandlersAndDeinitThread(_pthread_self(), -1/*PTHREAD_CANCELED*/);
       postMessage({ 'cmd': 'cancelDone' });
@@ -383,9 +419,12 @@ var LibraryPThread = {
         } else if (cmd === 'alert') {
           alert('Thread ' + d['threadId'] + ': ' + d['text']);
         } else if (cmd === 'exit') {
-          var detached = worker.pthread && Atomics.load(HEAPU32, (worker.pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.detached }}}) >> 2);
-          if (detached) {
-            PThread.returnWorkerToPool(worker);
+          if (worker.pthread) {
+            var detach_state = Atomics.load(HEAPU32, (worker.pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.detach_state }}}) >> 2);
+            // Only if it is fully exited can we return a worker the pool
+            if (detach_state == {{{ cDefine('DT_EXITED') }}}) {
+              PThread.returnWorkerToPool(worker);
+            }
           }
         } else if (cmd === 'exitProcess') {
           // A pthread has requested to exit the whole application process (runtime).
@@ -583,21 +622,21 @@ var LibraryPThread = {
       worker: worker,
       stackBase: threadParams.stackBase,
       stackSize: threadParams.stackSize,
+      initialState: {{{ cDefine('DT_JOINABLE') }}},
       allocatedOwnStack: threadParams.allocatedOwnStack,
       // Info area for this thread in Emscripten HEAP (shared)
       threadInfoStruct: threadParams.pthread_ptr
     };
     var tis = pthread.threadInfoStruct >> 2;
     // spawnThread is always called with a zero-initialized thread struct so
     // no need to set any valudes to zero here.
-    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.detached }}} >> 2), threadParams.detached);
-    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.tsd }}} >> 2), tlsMemory); // Init thread-local-storage memory array.
-    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.tid }}} >> 2), pthread.threadInfoStruct); // Main thread ID.
+    PThread.setDetachState(pthread.threadInfoStruct, threadParams.initialState);
+    // Init thread-local-storage memory array.
+    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.tsd }}} >> 2), tlsMemory);
+    // Main thread ID.
+    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.tid }}} >> 2), pthread.threadInfoStruct);
     Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.stack_size }}} >> 2), threadParams.stackSize);
     Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.stack }}} >> 2), stackHigh);
-    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.attr }}} >> 2), threadParams.stackSize);
-    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.attr }}} + 8 >> 2), stackHigh);
-    Atomics.store(HEAPU32, tis + ({{{ C_STRUCTS.pthread.attr }}} + 12 >> 2), threadParams.detached);
 
     var global_libc = _emscripten_get_global_libc();
     var global_locale = global_libc + {{{ C_STRUCTS.libc.global_locale }}};
@@ -770,23 +809,16 @@ var LibraryPThread = {
 
     var stackSize = 0;
     var stackBase = 0;
-    // Default thread attr is PTHREAD_CREATE_JOINABLE, i.e. start as not detached.
-    var detached = 0;
+    // Default thread state is DT_JOINABLE, i.e. start as not detached.
+    var initialState = {{{ cDefine('DT_JOINABLE') }}};
     // When musl creates C11 threads it passes __ATTRP_C11_THREAD (-1) which
     // treat as if it was NULL.
     if (attr && attr != {{{ cDefine('__ATTRP_C11_THREAD') }}}) {
-      stackSize = {{{ makeGetValue('attr', 0, 'i32') }}};
-      // Musl has a convention that the stack size that is stored to the pthread
-      // attribute structure is always musl's #define DEFAULT_STACK_SIZE
-      // smaller than the actual created stack size. That is, stored stack size
-      // of 0 would mean a stack of DEFAULT_STACK_SIZE in size. All musl
-      // functions hide this impl detail, and offset the size transparently, so
-      // pthread_*() API user does not see this offset when operating with
-      // the pthread API. When reading the structure directly on JS side
-      // however, we need to offset the size manually here.
-      stackSize += 81920 /*DEFAULT_STACK_SIZE*/;
-      stackBase = {{{ makeGetValue('attr', 8, 'i32') }}};
-      detached = {{{ makeGetValue('attr', 12/*_a_detach*/, 'i32') }}} !== 0/*PTHREAD_CREATE_JOINABLE*/;
+      stackSize = {{{ makeGetValue('attr', 0/*_a_stacksize*/, 'i32') }}};
+      stackBase = {{{ makeGetValue('attr', 8/*_a_stackaddr*/, 'i32') }}};
+      if ({{{ makeGetValue('attr', 12/*_a_detach*/, 'i32') }}}) {
+        initialState = {{{ cDefine('DT_DETACHED') }}};
+      }
     } else {
       // According to
       // http://man7.org/linux/man-pages/man3/pthread_create.3.html, default
@@ -834,7 +866,7 @@ var LibraryPThread = {
       stackBase: stackBase,
       stackSize: stackSize,
       allocatedOwnStack: allocatedOwnStack,
-      detached: detached,
+      initialState: initialState,
       startRoutine: start_routine,
       pthread_ptr: threadInfoStruct,
       arg: arg,
@@ -870,8 +902,8 @@ var LibraryPThread = {
     if (!tb) return;
     var cancelDisabled = Atomics.load(HEAPU32, (tb + {{{ C_STRUCTS.pthread.canceldisable }}} ) >> 2);
     if (cancelDisabled) return;
-    var canceled = Atomics.load(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2);
-    if (canceled == 2) throw 'Canceled!';
+    var canceled = Atomics.load(HEAPU32, (tb + {{{ C_STRUCTS.pthread.cancel }}} ) >> 2);
+    if (canceled) throw 'Canceled!';
   },
 
 #if MINIMAL_RUNTIME
@@ -913,28 +945,34 @@ var LibraryPThread = {
     }
     var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};
     if (self !== thread) {
-      err('pthread_join attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');
+      err('pthread_join attempted on thread 0x' + thread.toString(16) + ', which does not point to a valid thread, or does not exist anymore!');
       return ERRNO_CODES.ESRCH;
     }
 
-    var detached = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2);
-    if (detached) {
-      err('Attempted to join thread ' + thread + ', which was already detached!');
+    var detach_state = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}}) >> 2);
+    if (detach_state == {{{ cDefine('DT_DETACHED') }}}) {
+      err('Attempted to join thread 0x' + thread.toString(16) + ', which was already detached!');
       return ERRNO_CODES.EINVAL; // The thread is already detached, can no longer join it!
     }
 
+    if (detach_state == {{{ cDefine('DT_EXITED') }}}) {
+      err('Attempted to join thread 0x' + thread.toString(16) + ', which was already joined!');
+      return ERRNO_CODES.EINVAL;
+    }
+
 #if ASSERTIONS || IN_TEST_HARNESS || !MINIMAL_RUNTIME || !ALLOW_BLOCKING_ON_MAIN_THREAD
     if (block) {
       _emscripten_check_blocking_allowed();
     }
 #endif
 
     for (;;) {
-      var threadStatus = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2);
-      if (threadStatus == 1) { // Exited?
+      var detach_state = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}} ) >> 2);
+      if (detach_state == {{{ cDefine('DT_EXITING') }}}) { // Exiting?
         var threadExitCode = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2);
         if (status) {{{ makeSetValue('status', 0, 'threadExitCode', 'i32') }}};
-        Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2, 1); // Mark the thread as detached.
+        // Mark the thread as exited.
+        PThread.setDetachState(thread, {{{ cDefine('DT_EXITED') }}});
 
         if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread);
         else postMessage({ 'cmd': 'cleanupThread', 'thread': thread });
@@ -950,7 +988,7 @@ var LibraryPThread = {
       // runtime and launched main()), assist pthreads in performing operations
       // that they need to access the Emscripten main runtime for.
       if (!ENVIRONMENT_IS_PTHREAD) _emscripten_main_thread_process_queued_calls();
-      _emscripten_futex_wait(thread + {{{ C_STRUCTS.pthread.threadStatus }}}, threadStatus, ENVIRONMENT_IS_PTHREAD ? 100 : 1);
+      _emscripten_futex_wait(thread + {{{ C_STRUCTS.pthread.detach_state }}}, detach_state, ENVIRONMENT_IS_PTHREAD ? 100 : 1);
     }
   },
 
@@ -1003,7 +1041,8 @@ var LibraryPThread = {
       err('pthread_cancel attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');
       return ERRNO_CODES.ESRCH;
     }
-    Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 0, 2); // Signal the thread that it needs to cancel itself.
+    // Signal the thread that it needs to cancel itself.
+    Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.cancel }}}) >> 2, 1);
     if (!ENVIRONMENT_IS_PTHREAD) cancelThread(thread);
     else postMessage({ 'cmd': 'cancelThread', 'thread': thread});
     return 0;
@@ -1020,12 +1059,8 @@ var LibraryPThread = {
       err('pthread_detach attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');
       return ERRNO_CODES.ESRCH;
     }
-    // Follow musl convention: detached:0 means not detached, 1 means the thread
-    // was created as detached, and 2 means that the thread was detached via
-    // pthread_detach.
-    var wasDetached = Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2, 0, 2);
-
-    return wasDetached ? ERRNO_CODES.EINVAL : 0;
+    var oldState = PThread.swapDetachState(thread, {{{ cDefine('DT_JOINABLE') }}}, {{{ cDefine('DT_DETACHED') }}});
+    return oldState != {{{ cDefine('DT_JOINABLE') }}} ? ERRNO_CODES.EINVAL : 0;
   },
 
   // C11 threads function.

src/struct_info_internal.json

@@ -6,17 +6,16 @@
         "file": "pthread_impl.h",
         "structs": {
             "pthread": [
-              "threadStatus",
               "threadExitCode",
               "profilerBlock",
               "self",
               "tsd",
-              "detached",
+              "detach_state",
               "stack",
               "stack_size",
-              "attr",
               "robust_list",
               "tid",
+              "cancel",
               "canceldisable",
               "cancelasync",
               "locale"
@@ -30,7 +29,11 @@
         },
         "defines": [
           "__ATTRP_C11_THREAD",
-          "EM_THREAD_NAME_MAX"
+          "EM_THREAD_NAME_MAX",
+          "DT_EXITED",
+          "DT_EXITING",
+          "DT_JOINABLE",
+          "DT_DETACHED"
         ]
     },
     {

system/include/compat/sys/random.h

@@ -9,6 +9,8 @@ extern "C" {
 // syscall which is unnecessary indirection for us.
 int getentropy(void *buffer, size_t length);
 
+#include_next <sys/random.h>
+
 #ifdef __cplusplus
 }
 #endif

system/lib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

@@ -102,7 +102,11 @@ extern struct ps_strings *__ps_strings;
 #endif
 
 #if SANITIZER_EMSCRIPTEN
+#define weak __attribute__(__weak__)
+#define hidden __attribute__((__visibility__("hidden")))
 #include <syscall.h>
+#undef weak
+#undef hidden
 #include <emscripten/threading.h>
 #include <math.h>
 #include <wasi/api.h>

system/lib/dlmalloc.c

@@ -856,6 +856,10 @@ extern "C" {
 #ifndef USE_DL_PREFIX
 // XXX Emscripten XXX
 #if defined(__EMSCRIPTEN__)
+void* __libc_malloc(size_t) __attribute__((weak, alias("dlmalloc")));
+void  __libc_free(void*) __attribute__((weak, alias("dlfree")));
+void* __libc_calloc(size_t) __attribute__((weak, alias("dlcalloc")));
+void* __libc_realloc(void*, size_t) __attribute__((weak, alias("dlrealloc")));
 void* malloc(size_t) __attribute__((weak, alias("dlmalloc")));
 void  free(void*) __attribute__((weak, alias("dlfree")));
 void* calloc(size_t, size_t) __attribute__((weak, alias("dlcalloc")));

system/lib/emmalloc.cpp

@@ -794,6 +794,7 @@ void *emmalloc_memalign(size_t alignment, size_t size)
   return ptr;
 }
 extern __typeof(emmalloc_memalign) emscripten_builtin_memalign __attribute__((alias("emmalloc_memalign")));
+extern __typeof(emmalloc_memalign) __libc_memalign __attribute__((alias("emmalloc_memalign")));
 
 void * EMMALLOC_EXPORT memalign(size_t alignment, size_t size)
 {
@@ -812,6 +813,7 @@ void *emmalloc_malloc(size_t size)
   return emmalloc_memalign(MALLOC_ALIGNMENT, size);
 }
 extern __typeof(emmalloc_malloc) emscripten_builtin_malloc __attribute__((alias("emmalloc_malloc")));
+extern __typeof(emmalloc_malloc) __libc_malloc __attribute__((alias("emmalloc_malloc")));
 
 void * EMMALLOC_EXPORT malloc(size_t size)
 {
@@ -913,6 +915,7 @@ void emmalloc_free(void *ptr)
 #endif
 }
 extern __typeof(emmalloc_free) emscripten_builtin_free __attribute__((alias("emmalloc_free")));
+extern __typeof(emmalloc_free) __libc_free __attribute__((alias("emmalloc_free")));
 
 void EMMALLOC_EXPORT free(void *ptr)
 {
@@ -1133,6 +1136,7 @@ void *emmalloc_realloc(void *ptr, size_t size)
 {
   return emmalloc_aligned_realloc(ptr, MALLOC_ALIGNMENT, size);
 }
+extern __typeof(emmalloc_realloc) __libc_realloc __attribute__((alias("emmalloc_realloc")));
 
 void * EMMALLOC_EXPORT realloc(void *ptr, size_t size)
 {
@@ -1168,6 +1172,7 @@ void *emmalloc_calloc(size_t num, size_t size)
     memset(ptr, 0, bytes);
   return ptr;
 }
+extern __typeof(emmalloc_calloc) __libc_calloc __attribute__((alias("emmalloc_calloc")));
 
 void * EMMALLOC_EXPORT calloc(size_t num, size_t size)
 {

system/lib/libc/compat/aligned_alloc.c

@@ -2,7 +2,7 @@
 
 // Musl has an aligned_alloc routine, but that builds on top of standard malloc(). We are using dlmalloc, so
 // can route to its implementation instead.
-void * __attribute__((weak)) aligned_alloc(size_t alignment, size_t size)
+void * weak aligned_alloc(size_t alignment, size_t size)
 {
   void *ptr;
   if ((alignment % sizeof(void *) != 0) || (size % alignment) != 0)

system/lib/libc/crt1.c

@@ -12,7 +12,7 @@
 #include <stdlib.h>
 #include <wasi/api.h>
 
-__attribute__((weak)) void __wasm_call_ctors(void);
+__attribute__((__weak__)) void __wasm_call_ctors(void);
 
 int __original_main(void);
 

system/lib/libc/emscripten_asan_strchrnul.c

@@ -12,4 +12,4 @@ char *__strchrnul(const char *s, int c)
 			return (char *) s;
 }
 
-extern __typeof(__strchrnul) strchrnul __attribute__((weak, alias("__strchrnul")));
+extern __typeof(__strchrnul) strchrnul __attribute__((__weak__, alias("__strchrnul")));