Home | History | Annotate | Download | only in Coverage 
      1 //-*- C -*-
      2 
      3 /* This is a 
      4    multiline comment */
      5 
      6 // Intended to exercise all syntactic parts of the C language.
      7 
      8 int g0;
      9 int g1, g2;
     10 
     11 struct s0;
     12 
     13 struct s0 {
     14   int x;
     15 };
     16 
     17 int g3 = 10;
     18 
     19 __asm("");
     20 
     21 typedef int td0;
     22 
     23 td0 g4;
     24 
     25 enum e0 {
     26   ec0
     27 };
     28 
     29 static void f0(int x) {
     30 }
     31 
     32 inline void f0_0(int x) {
     33   ;
     34 }
     35 
     36 extern void f0_1(int x) {
     37 }
     38 
     39 void f1(int, ...);
     40 
     41 // Statements.
     42 void f2() {
     43   for (;;) {
     44     break;
     45     continue;
     46   }
     47 
     48   while (0) {
     49   }
     50 
     51   do {
     52   } while (0);
     53 
     54   void *label = &&theif;
     55   goto *label;
     56 
     57   goto theif;
     58 theif:
     59   if (0) {
     60     ;
     61   } else if (0) {
     62   } else {
     63   }
     64 
     65   switch(0) {
     66   case 0:
     67   case 1 ... 2:
     68     break;
     69   default:
     70     break;
     71   }
     72 
     73   asm ("nop");
     74 
     75   return;
     76 }
     77 
     78 // Expressions.
     79 
     80 #include <stdarg.h>
     81 
     82 typedef struct ipair {
     83   int first, second;
     84 } ipair;
     85 
     86 void f4(int a0, int a1, int a2, va_list ap) {
     87   int t0 = a0 ? a1 : a2;
     88   float t1 = (float) a0;
     89   ipair t2 = {1, 2};
     90   ipair t2a = { .second = 2 };
     91   int t3 = sizeof(ipair);
     92   ipair t4;
     93   t4 = (ipair) {1, 2};
     94   extern int g(int);
     95   int t5 = g(a0);
     96   int t6 = t4.first;
     97   int t7[10];
     98   int t8 = t7[a0];
     99   t8++;
    100   const char *t9 = __FUNCTION__;
    101   char t10 = 'x';
    102   int t11 = __builtin_offsetof(ipair, first);
    103   int t12 = __builtin_types_compatible_p(ipair, int);  
    104   int t12_0 = __builtin_classify_type(t0);
    105   int t12_1 = __builtin_classify_type(t1);
    106   int t12_2 = __builtin_classify_type(t2);
    107   // FIXME: Add _Complex and aggregate cases.
    108   int t13 = va_arg(ap, int);
    109   va_list t13_0;
    110   va_copy(t13_0, ap);
    111   int t14 = __extension__(t13);
    112   int t15 = +t13;
    113   unsigned t16 = t14 ^ t15;
    114   int t17 = t14 % t15;
    115   int t17_0 = t16 % t16;
    116   float t18;
    117   int t19 = t18 ? 0 : 1;
    118   char *t20; ++t20; --t20;
    119   float t21; ++t21; --t21;
    120   double t22; ++t22; --t22;
    121   long double t23; ++t23; --t23;
    122   int t24 = !t19;
    123   int t25 = __real t24;
    124   int t26 = __imag t24;
    125   const char *t27 = t9;
    126   t27 += (unsigned char) 0xFF;
    127   t27 += (signed char) 0xFF;
    128   
    129   struct { char f0[10]; } *t28;
    130   int t29 = t28 - t28;
    131   char *t30 = &t28->f0[1];
    132 
    133   struct s1 { int f0; };
    134   struct s1 t31_a, t31_b;
    135   int t31_cond;
    136   int t31 = (t31_cond ? t31_a : t31_b).f0;
    137 
    138   _Complex float t32_a, t32_b;
    139   int t32_cond;
    140   int t32 = __real (t32_cond ? t32_a : t32_b);
    141 
    142   struct { int x, y; } t33, *t34, t35[12], t36(int, float);
    143   float t37, *t38, t39[9], t40(double);
    144 }
    145 
    146 // Extended vectors
    147 
    148 typedef __attribute__((ext_vector_type(2))) float float2;
    149 typedef __attribute__((ext_vector_type(4))) float float4;
    150 
    151 void f5() {
    152   float4 t0 = (float4) { 0, 1, 2, 3 };
    153   float4 t1 = t0;
    154   t0.lo.even = t1.hi.x;
    155 
    156   // irgen doesn't support this yet.
    157 #if 0
    158   int t2_cond;
    159   float2 t2 = (t2_cond ? t0 : t1).lo;
    160 #endif
    161 }
    162 
    163 void f6() {
    164   const char *s0 = __func__;
    165   const char *s1 = __FUNCTION__;
    166   const char *s2 = __PRETTY_FUNCTION__;
    167 }
    168 
    169 // Arg mismatch with passed type.
    170 void f7(x) 
    171      float x;
    172 {
    173 }
    174 
    175 void f8(x) 
    176      short x;
    177 {
    178 }
    179 
    180 // Function which inputs an array
    181 void f9(int x[]) { }
    182 
    183 // Object literals.
    184 void f10() {
    185   struct f10_s0 {
    186     char iv0[10];
    187   } x;
    188 
    189   x = (struct f10_s0) { .iv0 = "name" };
    190 }
    191 
    192 // Nested structures.
    193 struct s11 {
    194   struct s11_2 {
    195     int f0;
    196   } f0;
    197   int f1;
    198 };
    199 
    200 // Unnamed structures.
    201 struct s12 {
    202   struct {
    203     unsigned char aa;
    204     unsigned char bb;
    205   };
    206 };
    207 
    208 void f11() {
    209   struct s12 var = { .aa = 33 };
    210 }
    211