Remove leaf attribute where appropriate

This change fixes a bug where gcc assumed thread synchronization such as
pthread_cond_wait() wouldn't alter static variables, because the headers
were using __attribute__((__leaf__)) inappropriately.

libc/cosmo.h

@@ -9,7 +9,7 @@ COSMOPOLITAN_C_START_
 #define _COSMO_ATOMIC(x) x
 #endif
 
-errno_t cosmo_once(_COSMO_ATOMIC(unsigned) *, void (*)(void)) libcesque;
+errno_t cosmo_once(_COSMO_ATOMIC(unsigned) *, void (*)(void));
 int systemvpe(const char *, char *const[], char *const[]) libcesque;
 char *GetProgramExecutableName(void) libcesque;
 void unleaf(void) libcesque;

libc/intrin/cxaatexit.h

@@ -18,9 +18,9 @@ struct CxaAtexitBlocks {
 
 extern struct CxaAtexitBlocks __cxa_blocks;
 
-void __cxa_lock(void) libcesque;
-void __cxa_unlock(void) libcesque;
-void __cxa_thread_finalize(void) libcesque;
+void __cxa_lock(void) dontthrow;
+void __cxa_unlock(void) dontthrow;
+void __cxa_thread_finalize(void) dontthrow;
 void __cxa_printexits(FILE *, void *) libcesque;
 int __cxa_thread_atexit_impl(void *, void *, void *);
 

libc/proc/proc.internal.h

@@ -41,8 +41,8 @@ struct Procs {
 
 extern struct Procs __proc;
 
-void __proc_lock(void) libcesque;
-void __proc_unlock(void) libcesque;
+void __proc_lock(void) dontthrow;
+void __proc_unlock(void) dontthrow;
 int64_t __proc_handle(int) libcesque;
 int64_t __proc_search(int) libcesque;
 struct Proc *__proc_new(void) libcesque;

libc/thread/posixthread.internal.h

@@ -97,30 +97,30 @@ extern atomic_uint _pthread_count;
 extern struct PosixThread _pthread_static;
 extern _Atomic(pthread_key_dtor) _pthread_key_dtor[PTHREAD_KEYS_MAX];
 
-int _pthread_cond_signal(pthread_cond_t *) libcesque paramsnonnull();
-int _pthread_mutex_lock(pthread_mutex_t *) libcesque paramsnonnull();
-int _pthread_mutex_trylock(pthread_mutex_t *) libcesque paramsnonnull();
-int _pthread_mutex_unlock(pthread_mutex_t *) libcesque paramsnonnull();
+int _pthread_cond_signal(pthread_cond_t *) dontthrow paramsnonnull();
+int _pthread_mutex_lock(pthread_mutex_t *) dontthrow paramsnonnull();
+int _pthread_mutex_trylock(pthread_mutex_t *) dontthrow paramsnonnull();
+int _pthread_mutex_unlock(pthread_mutex_t *) dontthrow paramsnonnull();
 int _pthread_mutex_wipe_np(pthread_mutex_t *) libcesque paramsnonnull();
 int _pthread_reschedule(struct PosixThread *) libcesque;
 int _pthread_setschedparam_freebsd(int, int, const struct sched_param *);
 int _pthread_tid(struct PosixThread *) libcesque;
 intptr_t _pthread_syshand(struct PosixThread *) libcesque;
 long _pthread_cancel_ack(void) libcesque;
-void _pthread_decimate(enum PosixThreadStatus) libcesque;
+void _pthread_decimate(enum PosixThreadStatus) dontthrow;
 void _pthread_free(struct PosixThread *) libcesque paramsnonnull();
-void _pthread_lock(void) libcesque;
-void _pthread_onfork_child(void) libcesque;
-void _pthread_onfork_parent(void) libcesque;
-void _pthread_onfork_prepare(void) libcesque;
-void _pthread_unlock(void) libcesque;
-void _pthread_zombify(struct PosixThread *) libcesque;
+void _pthread_lock(void) dontthrow;
+void _pthread_onfork_child(void) dontthrow;
+void _pthread_onfork_parent(void) dontthrow;
+void _pthread_onfork_prepare(void) dontthrow;
+void _pthread_unlock(void) dontthrow;
+void _pthread_zombify(struct PosixThread *) dontthrow;
 
-int _pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) libcesque
+int _pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) dontthrow
     paramsnonnull();
 
 int _pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *,
-                            const struct timespec *) libcesque
+                            const struct timespec *) dontthrow
     paramsnonnull((1, 2));
 
 forceinline pureconst struct PosixThread *_pthread_self(void) {

libc/thread/semaphore.h

@@ -34,10 +34,10 @@ typedef struct {
 
 int sem_init(sem_t *, int, unsigned) libcesque;
 int sem_destroy(sem_t *) libcesque;
-int sem_post(sem_t *) libcesque;
-int sem_wait(sem_t *) libcesque;
-int sem_trywait(sem_t *) libcesque;
-int sem_timedwait(sem_t *, const struct timespec *) libcesque;
+int sem_post(sem_t *) dontthrow;
+int sem_wait(sem_t *) dontthrow;
+int sem_trywait(sem_t *) dontthrow;
+int sem_timedwait(sem_t *, const struct timespec *) dontthrow;
 int sem_getvalue(sem_t *, int *) libcesque;
 sem_t *sem_open(const char *, int, ...) libcesque;
 int sem_close(sem_t *) libcesque;

libc/thread/thread.h

@@ -167,17 +167,17 @@ int pthread_attr_setstack(pthread_attr_t *, void *, size_t) libcesque paramsnonn
 int pthread_attr_setstacksize(pthread_attr_t *, size_t) libcesque paramsnonnull();
 int pthread_barrier_destroy(pthread_barrier_t *) libcesque paramsnonnull();
 int pthread_barrier_init(pthread_barrier_t *, const pthread_barrierattr_t *, unsigned) libcesque paramsnonnull((1));
-int pthread_barrier_wait(pthread_barrier_t *) libcesque paramsnonnull();
+int pthread_barrier_wait(pthread_barrier_t *) dontthrow paramsnonnull();
 int pthread_barrierattr_destroy(pthread_barrierattr_t *) libcesque paramsnonnull();
 int pthread_barrierattr_getpshared(const pthread_barrierattr_t *, int *) libcesque paramsnonnull();
 int pthread_barrierattr_init(pthread_barrierattr_t *) libcesque paramsnonnull();
 int pthread_barrierattr_setpshared(pthread_barrierattr_t *, int) libcesque paramsnonnull();
-int pthread_cancel(pthread_t) libcesque;
-int pthread_cond_broadcast(pthread_cond_t *) libcesque paramsnonnull();
+int pthread_cancel(pthread_t) dontthrow;
+int pthread_cond_broadcast(pthread_cond_t *) dontthrow paramsnonnull();
 int pthread_cond_destroy(pthread_cond_t *) libcesque paramsnonnull();
 int pthread_cond_init(pthread_cond_t *, const pthread_condattr_t *) libcesque paramsnonnull((1));
-int pthread_cond_signal(pthread_cond_t *) libcesque paramsnonnull();
-int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) libcesque paramsnonnull();
+int pthread_cond_signal(pthread_cond_t *) dontthrow paramsnonnull();
+int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) dontthrow paramsnonnull();
 int pthread_condattr_destroy(pthread_condattr_t *) libcesque paramsnonnull();
 int pthread_condattr_getclock(const pthread_condattr_t *, int *) libcesque paramsnonnull();
 int pthread_condattr_getpshared(const pthread_condattr_t *, int *) libcesque paramsnonnull();
@@ -185,23 +185,23 @@ int pthread_condattr_init(pthread_condattr_t *) libcesque paramsnonnull();
 int pthread_condattr_setclock(pthread_condattr_t *, int) libcesque paramsnonnull();
 int pthread_condattr_setpshared(pthread_condattr_t *, int) libcesque paramsnonnull();
 int pthread_create(pthread_t *, const pthread_attr_t *, void *(*)(void *), void *) dontthrow paramsnonnull((1));
-int pthread_decimate_np(void) libcesque;
-int pthread_delay_np(const void *, int) libcesque;
-int pthread_detach(pthread_t) libcesque;
+int pthread_decimate_np(void) dontthrow;
+int pthread_delay_np(const void *, int) dontthrow;
+int pthread_detach(pthread_t) dontthrow;
 int pthread_equal(pthread_t, pthread_t) libcesque;
 int pthread_getattr_np(pthread_t, pthread_attr_t *) libcesque paramsnonnull();
 int pthread_getname_np(pthread_t, char *, size_t) libcesque paramsnonnull();
 int pthread_getunique_np(pthread_t, pthread_id_np_t *) libcesque paramsnonnull();
-int pthread_join(pthread_t, void **) libcesque;
+int pthread_join(pthread_t, void **) dontthrow;
 int pthread_key_create(pthread_key_t *, pthread_key_dtor) libcesque paramsnonnull((1));
 int pthread_key_delete(pthread_key_t) libcesque;
-int pthread_kill(pthread_t, int) libcesque;
-int pthread_mutex_consistent(pthread_mutex_t *) libcesque paramsnonnull();
+int pthread_kill(pthread_t, int) dontthrow;
+int pthread_mutex_consistent(pthread_mutex_t *) dontthrow paramsnonnull();
 int pthread_mutex_destroy(pthread_mutex_t *) libcesque paramsnonnull();
 int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *) libcesque paramsnonnull((1));
-int pthread_mutex_lock(pthread_mutex_t *) libcesque paramsnonnull();
-int pthread_mutex_trylock(pthread_mutex_t *) libcesque paramsnonnull();
-int pthread_mutex_unlock(pthread_mutex_t *) libcesque paramsnonnull();
+int pthread_mutex_lock(pthread_mutex_t *) dontthrow paramsnonnull();
+int pthread_mutex_trylock(pthread_mutex_t *) dontthrow paramsnonnull();
+int pthread_mutex_unlock(pthread_mutex_t *) dontthrow paramsnonnull();
 int pthread_mutex_wipe_np(pthread_mutex_t *) libcesque paramsnonnull();
 int pthread_mutexattr_destroy(pthread_mutexattr_t *) libcesque paramsnonnull();
 int pthread_mutexattr_getpshared(const pthread_mutexattr_t *, int *) libcesque paramsnonnull();
@@ -215,11 +215,11 @@ int pthread_once(pthread_once_t *, void (*)(void)) paramsnonnull();
 int pthread_orphan_np(void) libcesque;
 int pthread_rwlock_destroy(pthread_rwlock_t *) libcesque paramsnonnull();
 int pthread_rwlock_init(pthread_rwlock_t *, const pthread_rwlockattr_t *) libcesque paramsnonnull((1));
-int pthread_rwlock_rdlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_tryrdlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_trywrlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_unlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_wrlock(pthread_rwlock_t *) libcesque paramsnonnull();
+int pthread_rwlock_rdlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_tryrdlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_trywrlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_unlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_wrlock(pthread_rwlock_t *) dontthrow paramsnonnull();
 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *) libcesque paramsnonnull();
 int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *, int *) libcesque paramsnonnull();
 int pthread_rwlockattr_init(pthread_rwlockattr_t *) libcesque paramsnonnull();
@@ -231,21 +231,21 @@ int pthread_setschedprio(pthread_t, int) libcesque;
 int pthread_setspecific(pthread_key_t, const void *) libcesque;
 int pthread_spin_destroy(pthread_spinlock_t *) libcesque paramsnonnull();
 int pthread_spin_init(pthread_spinlock_t *, int) libcesque paramsnonnull();
-int pthread_spin_lock(pthread_spinlock_t *) libcesque paramsnonnull();
-int pthread_spin_trylock(pthread_spinlock_t *) libcesque paramsnonnull();
-int pthread_spin_unlock(pthread_spinlock_t *) libcesque paramsnonnull();
-int pthread_testcancel_np(void) libcesque;
-int pthread_tryjoin_np(pthread_t, void **) libcesque;
-int pthread_yield(void) libcesque;
-int pthread_yield_np(void) libcesque;
+int pthread_spin_lock(pthread_spinlock_t *) dontthrow paramsnonnull();
+int pthread_spin_trylock(pthread_spinlock_t *) dontthrow paramsnonnull();
+int pthread_spin_unlock(pthread_spinlock_t *) dontthrow paramsnonnull();
+int pthread_testcancel_np(void) dontthrow;
+int pthread_tryjoin_np(pthread_t, void **) dontthrow;
+int pthread_yield(void) dontthrow;
+int pthread_yield_np(void) dontthrow;
 pthread_id_np_t pthread_getthreadid_np(void) libcesque;
 pthread_t pthread_self(void) libcesque pureconst;
 void *pthread_getspecific(pthread_key_t) libcesque;
-void pthread_cleanup_pop(struct _pthread_cleanup_buffer *, int) libcesque paramsnonnull();
-void pthread_cleanup_push(struct _pthread_cleanup_buffer *, void (*)(void *), void *) libcesque paramsnonnull((1));
-void pthread_exit(void *) libcesque wontreturn;
-void pthread_pause_np(void) libcesque;
-void pthread_testcancel(void) libcesque;
+void pthread_cleanup_pop(struct _pthread_cleanup_buffer *, int) dontthrow paramsnonnull();
+void pthread_cleanup_push(struct _pthread_cleanup_buffer *, void (*)(void *), void *) dontthrow paramsnonnull((1));
+void pthread_exit(void *) wontreturn;
+void pthread_pause_np(void) dontthrow;
+void pthread_testcancel(void) dontthrow;
 
 /* clang-format on */
 

libc/thread/thread2.h

@@ -13,12 +13,12 @@ int pthread_attr_getschedparam(const pthread_attr_t *, struct sched_param *) lib
 int pthread_attr_getsigmask_np(const pthread_attr_t *, sigset_t *) libcesque paramsnonnull((1));
 int pthread_attr_setschedparam(pthread_attr_t *, const struct sched_param *) libcesque paramsnonnull();
 int pthread_attr_setsigmask_np(pthread_attr_t *, const sigset_t *) libcesque paramsnonnull((1));
-int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *, const struct timespec *) libcesque paramsnonnull((1, 2));
+int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *, const struct timespec *) dontthrow paramsnonnull((1, 2));
 int pthread_getaffinity_np(pthread_t, size_t, cpu_set_t *) libcesque paramsnonnull();
 int pthread_getschedparam(pthread_t, int *, struct sched_param *) libcesque paramsnonnull();
 int pthread_setaffinity_np(pthread_t, size_t, const cpu_set_t *) libcesque paramsnonnull();
 int pthread_setschedparam(pthread_t, int, const struct sched_param *) libcesque paramsnonnull();
-int pthread_timedjoin_np(pthread_t, void **, struct timespec *) libcesque;
+int pthread_timedjoin_np(pthread_t, void **, struct timespec *) dontthrow;
 
 /* clang-format off */
 COSMOPOLITAN_C_END_

test/posix/forjustine_test.c

@@ -0,0 +1,49 @@
+// for justine with love 2025-01-02
+#include <poll.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static bool altstack_installed;
+
+static void* chump(void* v) {
+  stack_t* s = v;
+  if (sigaltstack(s, NULL)) {
+    pthread_mutex_lock(&lock);
+    altstack_installed = true;
+    pthread_mutex_unlock(&lock);
+    pthread_cond_signal(&cond);
+    return NULL;
+  }
+  pthread_mutex_lock(&lock);
+  altstack_installed = true;
+  pthread_cond_signal(&cond);
+  pthread_mutex_unlock(&lock);
+  while (1)
+    poll(NULL, 0, -1);
+  return NULL;
+}
+
+int main(void) {
+  void* v;
+  stack_t s = {.ss_size = sysconf(_SC_SIGSTKSZ)};
+  s.ss_sp = malloc(s.ss_size);
+  if (s.ss_sp == NULL)
+    return EXIT_FAILURE;
+  pthread_t tid;
+  if (pthread_create(&tid, NULL, chump, &s))
+    return EXIT_FAILURE;
+  pthread_mutex_lock(&lock);
+  while (!altstack_installed)
+    pthread_cond_wait(&cond, &lock);
+  pthread_mutex_unlock(&lock);
+  free(s.ss_sp);
+  if (pthread_cancel(tid) || pthread_join(tid, &v))
+    return EXIT_FAILURE;
+  return v == PTHREAD_CANCELED ? EXIT_SUCCESS : EXIT_FAILURE;
+}

test/posix/signal_latency_async_test.c

@@ -108,12 +108,8 @@ int compare(const void *a, const void *b) {
 
 int main() {
 
-  // Probably Qemu's fault
-  if (IsQemuUser())
-    return 0;
-
   // TODO(jart): fix flakes
-  if (IsWindows())
+  if (1)
     return 0;
 
   // Install signal handlers