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

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

我们提供的服务有：成都网站制作、网站建设、微信公众号开发、网站优化、网站认证、井陉ssl等。为近千家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的井陉网站制作公司

本文列出 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

当前标题：57个让C编译器崩溃的代码
标题来源：http://www.shufengxianlan.com/qtweb/news31/262231.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联