Add chibicc

This program popped up on Hacker News recently. It's the only modern
compiler I've ever seen that doesn't have dependencies and is easily
modified. So I added all of the missing GNU extensions I like to use
which means it might be possible soon to build on non-Linux and have
third party not vendor gcc binaries.

third_party/chibicc/test/arith_test.c

@@ -0,0 +1,341 @@
+#include "third_party/chibicc/test/test.h"
+
+int main() {
+  ASSERT(0, 0);
+  ASSERT(42, 42);
+  ASSERT(21, 5 + 20 - 4);
+  ASSERT(41, 12 + 34 - 5);
+  ASSERT(47, 5 + 6 * 7);
+  ASSERT(15, 5 * (9 - 6));
+  ASSERT(4, (3 + 5) / 2);
+  ASSERT(10, -10 + 20);
+
+  ASSERT(0, 0 == 1);
+  ASSERT(1, 42 == 42);
+  ASSERT(1, 0 != 1);
+  ASSERT(0, 42 != 42);
+
+  ASSERT(1, 0 < 1);
+  ASSERT(0, 1 < 1);
+  ASSERT(0, 2 < 1);
+  ASSERT(1, 0 <= 1);
+  ASSERT(1, 1 <= 1);
+  ASSERT(0, 2 <= 1);
+
+  ASSERT(1, 1 > 0);
+  ASSERT(0, 1 > 1);
+  ASSERT(0, 1 > 2);
+  ASSERT(1, 1 >= 0);
+  ASSERT(1, 1 >= 1);
+  ASSERT(0, 1 >= 2);
+
+  ASSERT(0, 1073741824 * 100 / 100);
+
+  ASSERT(7, ({
+           int i = 2;
+           i += 5;
+           i;
+         }));
+  ASSERT(7, ({
+           int i = 2;
+           i += 5;
+         }));
+  ASSERT(3, ({
+           int i = 5;
+           i -= 2;
+           i;
+         }));
+  ASSERT(3, ({
+           int i = 5;
+           i -= 2;
+         }));
+  ASSERT(6, ({
+           int i = 3;
+           i *= 2;
+           i;
+         }));
+  ASSERT(6, ({
+           int i = 3;
+           i *= 2;
+         }));
+  ASSERT(3, ({
+           int i = 6;
+           i /= 2;
+           i;
+         }));
+  ASSERT(3, ({
+           int i = 6;
+           i /= 2;
+         }));
+
+  ASSERT(3, ({
+           int i = 2;
+           ++i;
+         }));
+  ASSERT(2, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           ++*p;
+         }));
+  ASSERT(0, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           --*p;
+         }));
+
+  ASSERT(2, ({
+           int i = 2;
+           i++;
+         }));
+  ASSERT(2, ({
+           int i = 2;
+           i--;
+         }));
+  ASSERT(3, ({
+           int i = 2;
+           i++;
+           i;
+         }));
+  ASSERT(1, ({
+           int i = 2;
+           i--;
+           i;
+         }));
+  ASSERT(1, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           *p++;
+         }));
+  ASSERT(1, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           *p--;
+         }));
+
+  ASSERT(0, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p++)--;
+           a[0];
+         }));
+  ASSERT(0, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*(p--))--;
+           a[1];
+         }));
+  ASSERT(2, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p)--;
+           a[2];
+         }));
+  ASSERT(2, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p)--;
+           p++;
+           *p;
+         }));
+
+  ASSERT(0, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p++)--;
+           a[0];
+         }));
+  ASSERT(0, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p++)--;
+           a[1];
+         }));
+  ASSERT(2, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p++)--;
+           a[2];
+         }));
+  ASSERT(2, ({
+           int a[3];
+           a[0] = 0;
+           a[1] = 1;
+           a[2] = 2;
+           int *p = a + 1;
+           (*p++)--;
+           *p;
+         }));
+
+  ASSERT(0, !1);
+  ASSERT(0, !2);
+  ASSERT(1, !0);
+  ASSERT(1, !(char)0);
+  ASSERT(0, !(long)3);
+  ASSERT(4, sizeof(!(char)0));
+  ASSERT(4, sizeof(!(long)0));
+
+  ASSERT(-1, ~0);
+  ASSERT(0, ~-1);
+
+  ASSERT(5, 17 % 6);
+  ASSERT(5, ((long)17) % 6);
+  ASSERT(2, ({
+           int i = 10;
+           i %= 4;
+           i;
+         }));
+  ASSERT(2, ({
+           long i = 10;
+           i %= 4;
+           i;
+         }));
+
+  ASSERT(0, 0 & 1);
+  ASSERT(1, 3 & 1);
+  ASSERT(3, 7 & 3);
+  ASSERT(10, -1 & 10);
+
+  ASSERT(1, 0 | 1);
+  ASSERT(0b10011, 0b10000 | 0b00011);
+
+  ASSERT(0, 0 ^ 0);
+  ASSERT(0, 0b1111 ^ 0b1111);
+  ASSERT(0b110100, 0b111000 ^ 0b001100);
+
+  ASSERT(2, ({
+           int i = 6;
+           i &= 3;
+           i;
+         }));
+  ASSERT(7, ({
+           int i = 6;
+           i |= 3;
+           i;
+         }));
+  ASSERT(10, ({
+           int i = 15;
+           i ^= 5;
+           i;
+         }));
+
+  ASSERT(1, 1 << 0);
+  ASSERT(8, 1 << 3);
+  ASSERT(10, 5 << 1);
+  ASSERT(2, 5 >> 1);
+  ASSERT(-1, -1 >> 1);
+  ASSERT(1, ({
+           int i = 1;
+           i <<= 0;
+           i;
+         }));
+  ASSERT(8, ({
+           int i = 1;
+           i <<= 3;
+           i;
+         }));
+  ASSERT(10, ({
+           int i = 5;
+           i <<= 1;
+           i;
+         }));
+  ASSERT(2, ({
+           int i = 5;
+           i >>= 1;
+           i;
+         }));
+  ASSERT(-1, -1);
+  ASSERT(-1, ({
+    int i = -1;
+    i;
+  }));
+  ASSERT(-1, ({
+    int i = -1;
+    i >>= 1;
+    i;
+  }));
+
+  ASSERT(2, 0 ? 1 : 2);
+  ASSERT(1, 1 ? 1 : 2);
+  ASSERT(-1, 0 ? -2 : -1);
+  ASSERT(-2, 1 ? -2 : -1);
+  ASSERT(4, sizeof(0 ? 1 : 2));
+  ASSERT(8, sizeof(0 ? (long)1 : (long)2));
+  ASSERT(-1, 0 ? (long)-2 : -1);
+  ASSERT(-1, 0 ? -2 : (long)-1);
+  ASSERT(-2, 1 ? (long)-2 : -1);
+  ASSERT(-2, 1 ? -2 : (long)-1);
+
+  1 ? -2 : (void)-1;
+
+  ASSERT(20, ({
+           int x;
+           int *p = &x;
+           p + 20 - p;
+         }));
+  ASSERT(1, ({
+           int x;
+           int *p = &x;
+           p + 20 - p > 0;
+         }));
+  ASSERT(-20, ({
+    int x;
+    int *p = &x;
+    p - 20 - p;
+  }));
+  ASSERT(1, ({
+           int x;
+           int *p = &x;
+           p - 20 - p < 0;
+         }));
+
+  ASSERT(15, (char *)0xffffffffffffffff - (char *)0xfffffffffffffff0);
+  ASSERT(-15, (char *)0xfffffffffffffff0 - (char *)0xffffffffffffffff);
+  ASSERT(1, (void *)0xffffffffffffffff > (void *)0);
+
+  ASSERT(3, 3 ?: 5);
+  ASSERT(5, 0 ?: 5);
+  ASSERT(4, ({
+           int i = 3;
+           ++i ?: 10;
+         }));
+
+  ASSERT(3, (long double)3);
+  ASSERT(5, (long double)3 + 2);
+  ASSERT(6, (long double)3 * 2);
+  ASSERT(5, (long double)3 + 2.0);
+
+  return 0;
+}