Make improvements

- Fix unused local variable errors
- Remove yoinks from sigaction() header
- Add nox87 and aarch64 to github actions
- Fix cosmocc -fportcosmo in linking mode
- It's now possible to build `make m=llvm o/llvm/libc`

test/libc/mem/qsort_test.c

@@ -20,6 +20,7 @@
 #include "libc/macros.internal.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
+#include "libc/mem/gc.internal.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
@@ -28,6 +29,47 @@
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
 
+int CompareLow(const void *a, const void *b) {
+  const int *x = a;
+  const int *y = b;
+  if ((char)*x < (char)*y) return -1;
+  if ((char)*x > (char)*y) return +1;
+  return 0;
+}
+
+void InsertionSortLow(int *A, int n) {
+  int i, j, t;
+  for (i = 1; i < n; i++) {
+    t = A[i];
+    j = i - 1;
+    while (j >= 0 && (char)A[j] > (char)t) {
+      A[j + 1] = A[j];
+      j = j - 1;
+    }
+    A[j + 1] = t;
+  }
+}
+
+bool IsStableSort(void sort(void *, size_t, size_t,
+                            int (*)(const void *, const void *))) {
+  int n = 256;
+  int *A = gc(malloc(n * sizeof(int)));
+  int *B = gc(malloc(n * sizeof(int)));
+  rngset(A, n * sizeof(int), 0, 0);
+  memcpy(B, A, n * sizeof(int));
+  InsertionSortLow(A, n);
+  sort(B, n, sizeof(int), CompareLow);
+  return !memcmp(A, B, n * sizeof(int));
+}
+
+TEST(sort, stability) {
+  ASSERT_FALSE(IsStableSort(qsort));
+  ASSERT_FALSE(IsStableSort(smoothsort));
+  ASSERT_FALSE(IsStableSort((void *)qsort_r));
+  ASSERT_FALSE(IsStableSort((void *)heapsort));
+  ASSERT_TRUE(IsStableSort((void *)mergesort));
+}
+
 int CompareInt(const void *a, const void *b) {
   const int *x = a;
   const int *y = b;
@@ -44,7 +86,7 @@ int CompareLong(const void *a, const void *b) {
   return 0;
 }
 
-TEST(qsort, test) {
+TEST(qsort, words) {
   const int32_t A[][2] = {{4, 'a'},   {65, 'b'}, {2, 'c'}, {-31, 'd'},
                           {0, 'e'},   {99, 'f'}, {2, 'g'}, {83, 'h'},
                           {782, 'i'}, {1, 'j'}};
@@ -58,12 +100,38 @@ TEST(qsort, test) {
   free(M);
 }
 
+struct Record {
+  int x;
+  int y;
+  int z;
+  int a[2];
+  int b;
+};
+
+int CompareRecord(const void *a, const void *b) {
+  const struct Record *x = a;
+  const struct Record *y = b;
+  if (x->z > y->z) return -1;
+  if (x->z < y->z) return +1;
+  return 0;
+}
+
+TEST(qsort, records) {
+  int i, n = 256;
+  struct Record *A = gc(calloc(n, sizeof(struct Record)));
+  struct Record *B = gc(calloc(n, sizeof(struct Record)));
+  for (i = 0; i < n; ++i) A[i].z = B[i].z = lemur64();
+  qsort(A, n, sizeof(struct Record), CompareRecord);
+  mergesort(B, n, sizeof(struct Record), CompareRecord);
+  ASSERT_EQ(0, memcmp(A, B, n * sizeof(struct Record)));
+}
+
 TEST(qsort, equivalence_random) {
   size_t i;
   size_t n = 1000;
-  long *a = _gc(malloc(n * sizeof(long)));
-  long *b = _gc(malloc(n * sizeof(long)));
-  long *c = _gc(malloc(n * sizeof(long)));
+  long *a = gc(malloc(n * sizeof(long)));
+  long *b = gc(malloc(n * sizeof(long)));
+  long *c = gc(malloc(n * sizeof(long)));
   for (i = 0; i < n; ++i) a[i] = lemur64();
   memcpy(b, a, n * sizeof(long));
   memcpy(c, a, n * sizeof(long));
@@ -84,9 +152,9 @@ TEST(qsort, equivalence_random) {
 TEST(qsort, equivalence_reverse) {
   size_t i;
   size_t n = 1000;
-  long *a = _gc(malloc(n * sizeof(long)));
-  long *b = _gc(malloc(n * sizeof(long)));
-  long *c = _gc(malloc(n * sizeof(long)));
+  long *a = gc(malloc(n * sizeof(long)));
+  long *b = gc(malloc(n * sizeof(long)));
+  long *c = gc(malloc(n * sizeof(long)));
   for (i = 0; i < n; ++i) a[n - i - 1] = i;
   memcpy(b, a, n * sizeof(long));
   memcpy(c, a, n * sizeof(long));
@@ -107,13 +175,15 @@ TEST(qsort, equivalence_reverse) {
 BENCH(qsort, bench) {
   size_t i;
   size_t n = 1000;
-  long *p1 = _gc(malloc(n * sizeof(long)));
-  long *p2 = _gc(malloc(n * sizeof(long)));
+  long *p1 = gc(malloc(n * sizeof(long)));
+  long *p2 = gc(malloc(n * sizeof(long)));
 
   printf("\n");
   for (i = 0; i < n; ++i) p1[i] = i + ((lemur64() % 3) - 1);
   EZBENCH2("qsort nearly", memcpy(p2, p1, n * sizeof(long)),
            qsort(p2, n, sizeof(long), CompareLong));
+  EZBENCH2("qsort_r nearly", memcpy(p2, p1, n * sizeof(long)),
+           qsort_r(p2, n, sizeof(long), (void *)CompareLong, 0));
   EZBENCH2("heapsort nearly", memcpy(p2, p1, n * sizeof(long)),
            heapsort(p2, n, sizeof(long), CompareLong));
   EZBENCH2("mergesort nearly", memcpy(p2, p1, n * sizeof(long)),
@@ -127,6 +197,8 @@ BENCH(qsort, bench) {
   for (i = 0; i < n; ++i) p1[i] = n - i;
   EZBENCH2("qsort reverse", memcpy(p2, p1, n * sizeof(long)),
            qsort(p2, n, sizeof(long), CompareLong));
+  EZBENCH2("qsort_r reverse", memcpy(p2, p1, n * sizeof(long)),
+           qsort_r(p2, n, sizeof(long), (void *)CompareLong, 0));
   EZBENCH2("heapsort reverse", memcpy(p2, p1, n * sizeof(long)),
            heapsort(p2, n, sizeof(long), CompareLong));
   EZBENCH2("mergesort reverse", memcpy(p2, p1, n * sizeof(long)),
@@ -140,6 +212,8 @@ BENCH(qsort, bench) {
   rngset(p1, n * sizeof(long), 0, 0);
   EZBENCH2("qsort random", memcpy(p2, p1, n * sizeof(long)),
            qsort(p2, n, sizeof(long), CompareLong));
+  EZBENCH2("qsort_r random", memcpy(p2, p1, n * sizeof(long)),
+           qsort_r(p2, n, sizeof(long), (void *)CompareLong, 0));
   EZBENCH2("heapsort random", memcpy(p2, p1, n * sizeof(long)),
            heapsort(p2, n, sizeof(long), CompareLong));
   EZBENCH2("mergesort random", memcpy(p2, p1, n * sizeof(long)),
@@ -156,6 +230,8 @@ BENCH(qsort, bench) {
   }
   EZBENCH2("qsort 2n", memcpy(p2, p1, n * sizeof(long)),
            qsort(p2, n, sizeof(long), CompareLong));
+  EZBENCH2("qsort_r 2n", memcpy(p2, p1, n * sizeof(long)),
+           qsort_r(p2, n, sizeof(long), (void *)CompareLong, 0));
   EZBENCH2("heapsort 2n", memcpy(p2, p1, n * sizeof(long)),
            heapsort(p2, n, sizeof(long), CompareLong));
   EZBENCH2("mergesort 2n", memcpy(p2, p1, n * sizeof(long)),