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/common.c

@@ -0,0 +1,195 @@
+#include "third_party/chibicc/test/test.h"
+
+void Assert(long expected, long actual, char *code) {
+  if (expected != actual) {
+    fprintf(stderr, "%s => %ld expected but got %ld\n", code, expected, actual);
+    exit(1);
+  }
+}
+
+void Assert2(long expected, long actual, char *code, char *func, int line) {
+  if (expected != actual) {
+    fprintf(stderr, "%s:%d: %s => expected %ld but got %ld\n", func, line, code,
+            expected, actual);
+    exit(1);
+  }
+}
+
+void Assert128(__int128 k, __int128 x, char *code, char *func, int line) {
+  if (k != x) {
+    fprintf(stderr, "%s:%d: %s => want %jd but got %jd\n", func, line, code, k,
+            x);
+    exit(1);
+  }
+}
+
+static int static_fn() {
+  return 5;
+}
+
+int ext1 = 5;
+int *ext2 = &ext1;
+int ext3 = 7;
+
+int ext_fn1(int x) {
+  return x;
+}
+
+int ext_fn2(int x) {
+  return x;
+}
+
+int common_ext2 = 3;
+static int common_local;
+
+int false_fn() {
+  return 512;
+}
+
+int true_fn() {
+  return 513;
+}
+
+int char_fn() {
+  return (2 << 8) + 3;
+}
+
+int short_fn() {
+  return (2 << 16) + 5;
+}
+
+int uchar_fn() {
+  return (2 << 10) - 1 - 4;
+}
+
+int ushort_fn() {
+  return (2 << 20) - 1 - 7;
+}
+
+int schar_fn() {
+  return (2 << 10) - 1 - 4;
+}
+
+int sshort_fn() {
+  return (2 << 20) - 1 - 7;
+}
+
+int add_all(int n, ...) {
+  va_list ap;
+  va_start(ap, n);
+  int sum = 0;
+  for (int i = 0; i < n; i++) sum += va_arg(ap, int);
+  va_end(ap);
+  return sum;
+}
+
+float add_float(float x, float y) {
+  return x + y;
+}
+
+double add_double(double x, double y) {
+  return x + y;
+}
+
+int add10_int(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8,
+              int x9, int x10) {
+  return x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10;
+}
+
+float add10_float(float x1, float x2, float x3, float x4, float x5, float x6,
+                  float x7, float x8, float x9, float x10) {
+  return x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10;
+}
+
+double add10_double(double x1, double x2, double x3, double x4, double x5,
+                    double x6, double x7, double x8, double x9, double x10) {
+  return x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10;
+}
+
+typedef struct {
+  int a, b;
+  short c;
+  char d;
+} Ty4;
+
+typedef struct {
+  int a;
+  float b;
+  double c;
+} Ty5;
+
+typedef struct {
+  unsigned char a[3];
+} Ty6;
+
+typedef struct {
+  long a, b, c;
+} Ty7;
+
+int struct_test4(Ty4 x, int n) {
+  switch (n) {
+    case 0:
+      return x.a;
+    case 1:
+      return x.b;
+    case 2:
+      return x.c;
+    default:
+      return x.d;
+  }
+}
+
+int struct_test5(Ty5 x, int n) {
+  switch (n) {
+    case 0:
+      return x.a;
+    case 1:
+      return x.b;
+    default:
+      return x.c;
+  }
+}
+
+int struct_test6(Ty6 x, int n) {
+  return x.a[n];
+}
+
+int struct_test7(Ty7 x, int n) {
+  switch (n) {
+    case 0:
+      return x.a;
+    case 1:
+      return x.b;
+    default:
+      return x.c;
+  }
+}
+
+Ty4 struct_test24(void) {
+  return (Ty4){10, 20, 30, 40};
+}
+
+Ty5 struct_test25(void) {
+  return (Ty5){10, 20, 30};
+}
+
+Ty6 struct_test26(void) {
+  return (Ty6){{10, 20, 30}};
+}
+
+typedef struct {
+  unsigned char a[10];
+} Ty20;
+
+typedef struct {
+  unsigned char a[20];
+} Ty21;
+
+Ty20 struct_test27(void) {
+  return (Ty20){{10, 20, 30, 40, 50, 60, 70, 80, 90, 100}};
+}
+
+Ty21 struct_test28(void) {
+  return (Ty21){
+      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}};
+}