57个让C编译器崩溃的代码分别是怎样的

本篇文章给大家分享的是有关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;  }

以上就是57个让C编译器崩溃的代码分别是怎样的，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注编程网精选频道。