Update musl to v1.2.2

Author: sbc100

src/library_pthread.js

@@ -364,7 +364,7 @@ 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);
+          var detached = worker.pthread && Atomics.load(HEAPU32, (worker.pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.detach_state }}}) >> 2);
           if (detached) {
             PThread.returnWorkerToPool(worker);
           }
@@ -538,9 +538,10 @@ var LibraryPThread = {
     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.detach_state }}} >> 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.
+
     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);
@@ -863,7 +864,7 @@ var LibraryPThread = {
       return ERRNO_CODES.ESRCH;
     }
 
-    var detached = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2);
+    var detached = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}} ) >> 2);
     if (detached) {
       err('Attempted to join thread ' + thread + ', which was already detached!');
       return ERRNO_CODES.EINVAL; // The thread is already detached, can no longer join it!
@@ -880,7 +881,7 @@ var LibraryPThread = {
       if (threadStatus == 1) { // Exited?
         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.
+        Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}} ) >> 2, 1); // Mark the thread as detached.
 
         if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread);
         else postMessage({ 'cmd': 'cleanupThread', 'thread': thread });
@@ -969,7 +970,7 @@ var LibraryPThread = {
     // 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);
+    var wasDetached = Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detach_state }}} ) >> 2, 0, 2);
 
     return wasDetached ? ERRNO_CODES.EINVAL : 0;
   },

src/library_pthread_stub.js

@@ -23,6 +23,7 @@ var LibraryPThreadStub = {
     _pthread_cleanup_push.level = __ATEXIT__.length;
   },
 
+  pthread_cleanup_pop__deps: ['pthread_cleanup_push'],
   pthread_cleanup_pop__sig: 'vi',
   pthread_cleanup_pop: function(execute) {
     assert(_pthread_cleanup_push.level == __ATEXIT__.length, 'cannot pop if something else added meanwhile!');

src/struct_info.json

@@ -209,8 +209,7 @@
                 "tv_sec",
                 "tv_usec"
             ]
-        },
-        "defines": []
+        }
     },
     {
         "file": "time.h",

src/struct_info_internal.json

@@ -3,15 +3,15 @@
     // libc - internal
     // ===========================================
     {
-        "file": "system/lib/libc/musl/src/internal/pthread_impl.h",
+        "file": "pthread_impl.h",
         "structs": {
             "pthread": [
               "threadStatus",
               "threadExitCode",
               "profilerBlock",
               "self",
               "tsd",
-              "detached",
+              "detach_state",
               "stack",
               "stack_size",
               "attr",
@@ -25,7 +25,7 @@
         "defines": ["__ATTRP_C11_THREAD"]
     },
     {
-        "file": "system/lib/libc/musl/src/internal/libc.h",
+        "file": "libc.h",
         "structs": {
             "libc": [
               "global_locale"

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

@@ -772,6 +772,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)
 {
@@ -790,6 +791,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)
 {
@@ -891,6 +893,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)
 {
@@ -1086,6 +1089,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)
 {
@@ -1121,6 +1125,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);