57个让C编译器崩溃的代码

我不清楚你是否很高兴看到你的程序会让编译器崩溃的情况，反正我很喜欢，相当于发现了编译器的 bug。

本文列出 57 段代码以及相应的编译器版本和编译参数，在这个环境下对代码进行编译会导致编译器崩溃。

C1 : Crashes Clang 2.6 at -O0:

#pragma pack(1)  
struct S1 {  
  int f0;  
  char f2  
};  
struct {  
  struct S1 f0  
    }  
a[] = { 0 }  
      ; 

C2 : Crashes Clang 2.6 at -O2:

struct S0 {  
  int f0:1;  
  int f4  
}  
a;  
void 
fn1 () {  
  struct S0 b[][1][1] = { 0 };  
  b[0][0][0] = a;  
} 

C3 : Crashes Clang 2.6 at -O2:

unsigned short a;  
int b;  
char c;  
short 
fn1 () {  
  return 1 / a;  
}  
void 
fn2 () {  
  b = fn1 ();  
  char d = b;  
  c = d % 3;  
} 

C4 : Crashes Clang 2.6 at -O3:

int a, b, c, d, e;  
#pragma pack(1)  
struct S0 {  
  int f0:14;  
  int f1:13;  
  int f2:28;  
  int f3:23;  
  int f4:12  
};  
void fn1 (struct S0);  
void 
fn2 () {  
  int f;  
lbl_2311:  
  ;  
  struct S0 g = { 0, 0, 1 };  
  fn1 (g);  
  b && e;  
  for (; c;) {  
    if (d)  
      goto lbl_2311;  
    f = a && 1 ? 0 : 1;  
    g.f4 = f;  
  }  
} 

C5 : Crashes Clang 2.6 at -O2:

 int crc32_context, g_2 = 0, g_5;  
int g_8;  
int *g_39, *g_371;  
int g_81;  
int func_1_l_15 ;  
static short safe_add_func_int16_t_s_s ( short si1, int si2 ) {  
    return si1 > 67 ? si1 : si1 + si2;  
  }  
 
    static int func_1 (  ) {  
    int l_462 = 0;  
    g_2 = 0;  
    for ( ;  
  g_2 < 12;  
  g_2 = safe_add_func_int16_t_s_s ( g_2, 5 ) )     {  
       g_5 = 1;  
       for ( ;  
 g_5;  
 ++g_5 )    {  
      g_8 = 1;  
      for ( ;  
 g_8 >= 0;  
 g_8 = g_8 - 1 )        {  
          func_1_l_15 = 1;  
          for ( ;  
 func_1_l_15;  
            func_1_l_15 =   func_1_l_15  - 1  )         if ( g_8 )        break;  
        }  
      g_371 = &l_462;  
      int *l_128 = &g_81;  
      *l_128 = *g_39;  
    }  
 *g_371 =    0 != 0   ;  
     }  
    return 0;  
  }  
   int main (  ) {  
    func_1 (  );  
    crc32_context = g_2;  
    crc32_context += g_5;  
  }  
   

C6 : Crashes Clang 2.6 at -O0:

#pragma pack(1)  
struct S2 {  
  int f1;  
  short f4  
};  
struct S3 {  
  struct S2 f1;  
  int f3:14  
};  
struct {  
  struct S3 f3  
    }  
a = { 0, 0, 0 }; 

C7 : Crashes Clang 2.6 at -O1:

int *a;  
static int **b;  
int c, d, e;  
void 
fn1 () {  
  d = &b == c;  
  for (;;) {  
    int **f = &a;  
    if (e) {  
    } else 
      b = f;  
    if (**b)  
      continue;  
    **f;  
  }  
} 

C8 : Crashes Clang 2.6 at -O1:

#pragma pack(1)  
struct S0 {  
  int f3;  
  char f4  
};  
struct {  
  struct S0 f6;  
  int f8  
}  
a = { 0, 0, 0 }; 

C9 : Crashes Clang 2.6 at -O2:

struct S0 {  
  int f0;  
  int f1;  
  short f3;  
  int f7;  
  int f8  
}  
b;  
int a, c, d, e, f;  
void 
fn1 (struct S0 p1) {  
  d++;  
  c = p1.f8;  
  e = 0;  
  a = p1.f7;  
}  
void 
fn2 () {  
  e = 0;  
  for (; e; e++) {  
    if (d)  
      for (;;) {  
      }  
    --f;  
  }  
  fn1 (b);  
} 

C10 : Crashes Clang 2.6 at -O1:

union U2 {  
  int f0;  
  unsigned short f2  
}  
b;  
static int a = 1;  
void 
fn1 (int p1, unsigned short p2) {  
}  
int fn2 (union U2);  
union U2 fn3 ();  
static unsigned long long 
fn5 () {  
  fn1 (b.f2, b.f0);  
  return 0;  
}  
static char 
fn4 () {  
  fn5 ();  
  return 0;  
}  
int 
main () {  
  a || fn2 (fn3 (fn4 () ) );  
} 

C11 : Crashes Clang 2.7 at -O1:

int *a;  
static int **b;  
int c, d, e;  
void 
fn1 () {  
  d = &b == c;  
  for (;;) {  
    int **f = &a;  
    if (e) {  
    } else 
      b = f;  
    if (**b)  
      continue;  
    **f;  
  }  
} 

C12 : Crashes Clang 2.7 at -O0:

char a;  
unsigned char b;  
int c;  
void 
fn1 () {  
  (b ^= c) != a;  
} 

C13 : Crashes Clang 2.7 at -O2:

int a, b;  
void fn1 ();  
void 
fn2 (short p1) {  
  short c;  
  c = (65532 | 3) + p1;  
  fn1 (c && 1);  
  b = (0 == p1) * a;  
} 

C14 : Crashes GCC 3.2.0 at -O1:

void 
fn1 () {  
  struct S0 *a;  
  struct S0 *b, *c = &a;  
  struct S0 **d = &c;  
  if (&b == &a) {  
  }  
} 

C15 : Crashes GCC 3.2.0 at -O3:

volatile int a, b, c, i;  
char d;  
void 
fn1 () {  
  int e;  
  {  
    for (;; c++) {  
      int f[50] = { };  
      if (b) {  
        {  
          0;  
          {  
            {  
              int g = a, h = d;  
              e = h ? g : g / 0;  
            }  
          }  
          a = e;  
        }  
      }  
    }  
  }  
}  
void 
main () {  
  i = 0 / 0;  
  a;  
} 

C16 : Crashes GCC 3.2.0 at -O3:

int a, c;  
volatile int b;  
void 
fn1 () {  
  b;  
  for (;;)  
    break;  
  int d = b, e = a;  
  c = a ? d : d % 0;  
}  
void 
fn2 () {  
  if (0 % 0)  
    b;  
} 

C17 : Crashes GCC 3.2.0 at -O2:

union U1 {  
  int f0;  
  char f1  
};  
void 
fn1 (union U1 p1) {  
  p1.f1 = 0;  
  for (; p1.f1;) {  
  }  
} 

C18 : Crashes GCC 3.2.0 at -O1:

int a, b;  
void 
fn1 () {  
  b = 4294967290UL <= a | b;  
} 

C19 : Crashes GCC 3.2.0 at -O3:

int a, b, c;  
int 
fn1 (int p1, int p2) {  
  return p1 - p2;  
}  
void 
fn2 () {  
  int d;  
  int **e;  
  int ***f = &e;  
  d = a && b ? a : a % 0;  
  if (fn1 (f == 0, 2) )  
    c = ***f;  
} 

C20 : Crashes GCC 3.3.0 at -O3:

int a, b, d;  
struct S0 {  
  int f3  
};  
int *volatile c;  
void fn1 (struct S0);  
void 
fn2 () {  
  int e;  
  struct S0 **f;  
  struct S0 ***g = &f;  
  (a && b && b ? 0 : b) > (&c && 0);  
  e = 0 == g;  
  d = e >> 1;  
  for (;;)  
    fn1 (***g);  
} 

C21 : Crashes GCC 3.4.0 at -O3:

int a, b;  
struct U0 {  
  char f0;  
  int f2  
};  
void 
fn1 () {  
  struct U0 c;  
  for (; c.f0 != 1; c.f0 = c.f0 + a)  
    b -= 1;  
} 

C22 : Crashes GCC 3.4.0 at -O3:

int a, b, d, e;  
struct S0 {  
  int f3  
};  
int *c;  
void fn1 (struct S0);  
void 
fn2 () {  
  struct S0 **f;  
  struct S0 ***g = &f;  
  (a && b && b ? 0 : b) > (&c == d);  
  e = 1 < (0 == g);  
  for (;;)  
    fn1 (***g);  
} 

C23 : Crashes GCC 4.0.0 at -O2:

int ***a;  
int b;  
int *c;  
void 
main () {  
  if (&c == a)  
    b = 0 == *a;  
} 

C24 : Crashes GCC 4.0.0 at -O2:

int a[][0];  
int *const b = &a[0][1];  
int 
fn1 () {  
  return *b;  
} 

C25 : Crashes GCC 4.0.0 at -O0:

int a, b;  
unsigned char c;  
void 
fn1 () {  
  (0 >= a & (0 || b) ) > c;  
} 

C26 : Crashes GCC 4.0.0 at -O1:

struct {  
  int f9:1  
}  
a;  
const int b[] = { 0 };  
void fn1 ();  
void 
main () {  
  for (;;) {  
    a.f9 = b[0];  
    fn1 ();  
  }  
} 

C27 : Crashes GCC 4.0.0 at -O0:

int a, c;  
unsigned char b;  
void 
fn1 () {  
  b > (c > 0 & 0 < a);  
} 

C28 : Crashes GCC 4.0.0 at -O2:

int **a[][0];  
static int ***const b = &a[0][1];  
void fn1 ();  
int 
fn2 () {  
  return ***b;  
  fn1 ();  
}  
void 
fn1 () {  
  **b;  
} 

C29 : Crashes GCC 4.1.0 at -O1:

volatile int ***a;  
int b;  
int **c;  
void 
fn1 () {  
  if (&c == a)  
    b = 0 == *a;  
} 

C30 : Crashes GCC 4.1.0 at -O1:

struct {  
  int f0;  
  int f2  
}  
a;  
int b;  
void 
fn1 () {  
  a.f2 = 0;  
  int *c[] = { 0, 0, 0, 0, &a.f0, 0, 0, 0, &a.f0 };  
  b = *c[4];  
} 

C31 : Crashes GCC 4.1.0 at -O2:

int a, b;  
unsigned c;  
void 
fn1 () {  
  for (; c <= 0;)  
    if (b < c)  
      a = 1 && c;  
} 

C32 : Crashes GCC 4.1.0 at -O1:

unsigned a;  
int b;  
void 
main () {  
  unsigned c = 4294967295;  
  int d = c;  
  b = a <= d || a;  
} 

C33 : Crashes GCC 4.1.0 at -O1:

const volatile long a;  
void 
main () {  
  printf ("%d\n", (int) a);  
} 

C34 : Crashes GCC 4.1.0 at -O3:

int a, b;  
union U1 {  
  int f0;  
  int f1  
};  
void 
fn1 () {  
  union U1 c = { 1 };  
  int d = 1;  
  if ( (c.f1 & a ? c.f1 : 1 - a) ^ d) {  
  } else 
    b = 0;  
} 

C35 : Crashes GCC 4.2.0 at -O1:

volatile int ***a;  
int b;  
int **c;  
void 
fn1 () {  
  if (&c == a)  
    b = 0 == *a;  
} 

C36 : Crashes GCC 4.2.0 at -O1:

struct S2 {  
  volatile int f5:1;  
  int f6  
};  
static struct S2 a;  
void 
main () {  
  printf ("%d\n", a.f5);  
} 

C37 : Crashes GCC 4.3.0 at -O1:

long long *a;  
int b;  
void 
fn1 () {  
  long long **c = &a;  
  int d = 7;  
lbl_2890: {  
    long long **e = &a;  
    b = (e == c) < d;  
    d = 0;  
    goto lbl_2890;  
  }  
} 

C38 : Crashes GCC 4.3.0 at -O2:

struct S2 {  
  volatile int f5:1;  
  int f6  
};  
static struct S2 a;  
void 
main () {  
  printf ("%d\n", a.f5);  
} 

C39 : Crashes GCC 4.3.0 at -O3:

int a;  
short b;  
void 
fn1 () {  
  int c[0];  
  for (;;) {  
    a = c[0];  
    b = 0;  
    for (; b < 7; b += 1)  
      c[b] = 0;  
  }  
} 

C40 : Crashes GCC 4.3.0 at -O1:

volatile int **a;  
int *b;  
void 
fn1 () {  
  if (a == &b)  
    **a;  
} 

C41 : Crashes GCC 4.3.0 at -O3:

int a, b, c, d, e, f;  
void 
fn1 () {  
  char g;  
lbl_120:  
  if (b || e >= 0 & d >= 0 || a)  
    return;  
  g = f < 0 ? 1 : f;  
  d = g == 0 || (char) f == 0 && g == 1 ? 0 : 0 % 0;  
  if (c)  
    goto lbl_120;  
} 

C42 : Crashes Intel CC 12.0.5 at -O1:

struct U0 {  
  int f0  
}  
a;  
struct U0  
fn1 () {  
  return a;  
}  
void 
main () {  
  0 > a.f0;  
  fn1 ();  
} 

C43 : Crashes Open64 4.2.4 at -O3:

int a;  
int *b;  
unsigned c;  
void 
fn1 () {  
  for (; a; a--)  
    if (*b) {  
      c = 0;  
      for (; c >= 5; c++) {  
      }  
    }  
} 

C44 : Crashes Open64 4.2.4 at -O3:

short a;  
void 
fn1 () {  
  long b;  
  b = 44067713550;  
  a |= b;  
} 

C45 : Crashes Open64 4.2.4 at -O3:

volatile int a;  
void 
fn1 () {  
  int b = 1;  
  a || b--;  
} 

C46 : Crashes Open64 4.2.4 at -O2:

int a, b;  
void fn1 ();  
void fn2 ();  
void 
fn3 () {  
  fn2 ();  
  fn1 ();  
}  
void 
fn2 () {  
  if (1) {  
  } else 
    for (;; b++) {  
      int c = 0;  
      int *d = &a;  
      int **e = &d;  
      *e = &c;  
      *d = 0;  
      *d |= 0;  
    }  
} 

C47 : Crashes Open64 4.2.4 at -O3:

struct S0 {  
  int f1:1  
};  
int a, b;  
void 
fn1 () {  
  for (; b;) {  
    struct S0 c = { };  
    if (1) {  
      c = c;  
      a = c.f1;  
    }  
  }  
} 

C48 : Crashes Open64 4.2.4 at -O3:

int a, b;  
int 
fn1 () {  
  int *c = &b;  
  a = 0;  
  for (; a >= -26; --a) {  
    unsigned d = 18446744073709551615;  
    int *e = &b;  
    *e &= d;  
  }  
  return *c;  
} 

C49 : Crashes Open64 4.2.4 at -O3:

static int a, c, d;  
int b;  
int *e;  
void 
fn1 () {  
  for (; a; a += 1) {  
    b = 0;  
    for (; b > -16; --b)  
      for (; c;) {  
        int *f = &d;  
        *f = 0;  
      } *e = 0;  
  }  
} 

C50 : Crashes Sun CC 5.11 at -xO4:

unsigned char a, d;  
struct {  
  int f2  
}  
b;  
int c, e;  
void 
fn1 (p1) {  
}  
void 
fn2 () {  
  c = 0;  
  for (; c <= 0;)  
    e = b.f2;  
  fn1 (0);  
  b = b;  
  d = -a;  
} 

C51 : Crashes Sun CC 5.11 at -fast:

int a, c;  
int b[1];  
void 
fn1 () {  
  short d;  
  for (; a; a -= 1) {  
    d = b1 = b1;  
    b[0] = 0;  
  }  
} 

C52 : Crashes Sun CC 5.11 at -xO4:

int a, b, d;  
short c;  
int 
fn1 (p1) {  
  return a ? 0 : p1;  
}  
void 
fn2 () {  
  int e = 0;  
  for (;;) {  
    c = 0;  
    d = fn1 (e ^ ~~c);  
    d && b;  
  }  
} 

C53 : Crashes Sun CC 5.11 at -fast:

long a;  
int b, d;  
int *c;  
void 
fn1 () {  
  int *e;  
  for (;; b--)  
    for (; d;) {  
      *c = 0;  
      *c &= (&e != 1) / a;  
    }  
} 

C54 : Crashes Sun CC 5.11 at -xO0:

#pragma pack(1)  
struct {  
  int f3:1;  
  int f4:16  
}  
a = { 1, 0 }; 

C55 : Crashes Sun CC 5.11 at -xO3:

int a, c;  
static int b = 1;  
void fn1 ();  
void 
fn2 () {  
  for (; a; a--) {  
    c = 0;  
    for (; c != 1;) {  
      if (b)  
        break;  
      fn1 ();  
    }  
  }  
} 

C56 : Crashes Sun CC 5.11 at -xO4:

#pragma pack(1)  
struct S0 {  
  int f1;  
  int f3:1  
}  
a;  
void 
fn1 (struct S0 p1) {  
  p1.f3 = 0;  
}  
void 
fn2 () {  
  fn1 (a);  
} 

C57 : Crashes Sun CC 5.11 at -fast:

int a, c, d, e, f, g, h, i, j, k;  
volatile int b;  
int 
fn1 () {  
  for (; d; d = a) {  
    int *l = &c;  
    c = -3;  
    for (; c > -23; --c)  
      if (k) {  
        if (*l)  
          continue;  
        return b;  
      }  
    for (; i; ++i) {  
      j = 0;  
      g = h;  
      for (; f <= 1; f += 1) {  
      }  
    }  
  }  
  return e;  
} 

英文：http://blog.regehr.org/archives/696

原文链接：http://www.oschina.net/question/12_46847

【编辑推荐】

1. 详解Objective-C 与 C++区别之分
2. 浅谈Objective-C协议和委托
3. 浅谈Objective-C代理方案
4. 浅谈Objective-C编码规范
5. 详解Objective-C中变量和数据类型