clang/test/Sema/init.c

   1 // RUN: %clang_cc1 %s -Wno-pointer-to-int-cast -verify -fsyntax-only -ffreestanding
   2
   3 #include <stddef.h>
   4 #include <stdint.h>
   5
   6 typedef void (* fp)(void);
   7 void foo(void);
   8
   9 // PR clang/3377
  10 fp a[(short int)1] = { foo };
  11
  12 int myArray[5] = {1, 2, 3, 4, 5};
  13 int *myPointer2 = myArray;
  14 int *myPointer = &(myArray[2]);
  15
  16
  17 extern int x;
  18 void *g = &x;
  19 int *h = &x;
  20
  21 struct union_crash
  22 {
  23     union
  24     {
  25     };
  26 };
  27
  28 int test(void) {
  29   int a[10];
  30   int b[10] = a; // expected-error {{array initializer must be an initializer list}}
  31   int +; // expected-error {{expected identifier or '('}}
  32
  33   struct union_crash u = { .d = 1 }; // expected-error {{field designator 'd' does not refer to any field in type 'struct union_crash'}}
  34 }
  35
  36
  37 // PR2050
  38 struct cdiff_cmd {
  39           const char *name;
  40           unsigned short argc;
  41           int (*handler)(void);
  42 };
  43 int cdiff_cmd_open(void);
  44 struct cdiff_cmd commands[] = {
  45         {"OPEN", 1, &cdiff_cmd_open }
  46 };
  47
  48 // PR2348
  49 static struct { int z; } s[2];
  50 int *t = &(*s).z;
  51
  52 // PR2349
  53 short *a2(void)
  54 {
  55   short int b;
  56   static short *bp = &b; // expected-error {{initializer element is not a compile-time constant}}
  57
  58   return bp;
  59 }
  60
  61 int pbool(void) {
  62   typedef const _Bool cbool;
  63   _Bool pbool1 = (void *) 0;
  64   cbool pbool2 = &pbool;
  65   return pbool2;
  66 }
  67
  68
  69 union { float f; unsigned u; } u = { 1.0f };
  70
  71 int f3(int x) { return x; }
  72 typedef void (*vfunc)(void);
  73 void *bar = (vfunc) f3;
  74
  75 // PR2747
  76 struct sym_reg {
  77         char nc_gpreg;
  78 };
  79 int sym_fw1a_scr[] = {
  80            ((int)(&((struct sym_reg *)0)->nc_gpreg)) & 0,
  81            8 * ((int)(&((struct sym_reg *)0)->nc_gpreg))
  82 };
  83
  84 // PR3001
  85 struct s1 s2 = { // expected-error {{variable has incomplete type 'struct s1'}}  \
  86                  // expected-note {{forward declaration of 'struct s1'}}
  87     .a = sizeof(struct s3), // expected-error {{invalid application of 'sizeof'}} \
  88                             // expected-note{{forward declaration of 'struct s3'}}
  89     .b = bogus // expected-error {{use of undeclared identifier 'bogus'}}
  90 }
  91
  92 // PR3382
  93 char t[] = ("Hello");
  94
  95 typedef struct { } empty;
  96
  97 typedef struct {
  98   empty e;
  99   int i2;
 100 } st;
 101
 102 st st1 = { .i2 = 1 };
 103
 104 struct {
 105   int a;
 106   int z[2];
 107 } y = { .z = {} };
 108
 109 int bbb[10];
 110
 111 struct foo2 {
 112    uintptr_t a;
 113 };
 114
 115 struct foo2 bar2[] = {
 116    { (intptr_t)bbb }
 117 };
 118
 119 struct foo2 bar3 = { 1, 2 }; // expected-warning{{excess elements in struct initializer}}
 120 #pragma clang diagnostic push
 121 #pragma clang diagnostic ignored "-Wexcess-initializers"
 122 struct foo2 bar3_silent = {1, 2};
 123 #pragma clang diagnostic pop
 124
 125 int* ptest1 = __builtin_choose_expr(1, (int*)0, (int*)0);
 126
 127 typedef int32_t ivector4 __attribute((vector_size(16)));
 128 ivector4 vtest1 = 1 ? (ivector4){1} : (ivector4){1};
 129 ivector4 vtest2 = __builtin_choose_expr(1, (ivector4){1}, (ivector4){1});
 130
 131 uintptr_t ptrasintadd1 = (uintptr_t)&a - 4;
 132 uintptr_t ptrasintadd2 = (uintptr_t)&a + 4;
 133 uintptr_t ptrasintadd3 = 4 + (uintptr_t)&a;
 134
 135 // PR4285
 136 const wchar_t widestr[] = L"asdf";
 137
 138 // PR5447
 139 const double pr5447 = (0.05 < -1.0) ? -1.0 : 0.0499878;
 140
 141 // PR4386
 142
 143 // None of these are constant initializers, but we implement GCC's old
 144 // behaviour of accepting bar and zed but not foo. GCC's behaviour was
 145 // changed in 2007 (rev 122551), so we should be able to change too one
 146 // day.
 147 int PR4386_bar(void);
 148 int PR4386_foo(void) __attribute((weak));
 149 int PR4386_zed(void);
 150
 151 int PR4386_a = ((void *) PR4386_bar) != 0;
 152 int PR4386_b = ((void *) PR4386_foo) != 0; // expected-error{{initializer element is not a compile-time constant}}
 153 int PR4386_c = ((void *) PR4386_zed) != 0;
 154 int PR4386_zed(void) __attribute((weak));
 155
 156 // (derived from SPEC vortex benchmark)
 157 typedef char strty[10];
 158 struct vortexstruct { strty s; };
 159 struct vortexstruct vortexvar = { "asdf" };
 160
 161 typedef struct { uintptr_t x : 2; } StructWithBitfield;
 162 StructWithBitfield bitfieldvar = { (uintptr_t)&bitfieldvar }; // expected-error {{initializer element is not a compile-time constant}}
 163
 164 // PR45157
 165 struct PR4517_foo {
 166   int x;
 167 };
 168 struct PR4517_bar {
 169   struct PR4517_foo foo;
 170 };
 171 const struct PR4517_foo my_foo = {.x = 42};
 172 struct PR4517_bar my_bar = {
 173     .foo = my_foo, // no-warning
 174 };
 175 struct PR4517_bar my_bar2 = (struct PR4517_bar){
 176     .foo = my_foo, // no-warning
 177 };
 178 struct PR4517_bar my_bar3 = {
 179     my_foo, // no-warning
 180 };
 181 struct PR4517_bar my_bar4 = (struct PR4517_bar){
 182     my_foo // no-warning
 183 };
 184 extern const struct PR4517_foo my_foo2;
 185 struct PR4517_bar my_bar5 = {
 186   .foo = my_foo2, // expected-error {{initializer element is not a compile-time constant}}
 187 };
 188 const struct PR4517_foo my_foo3 = {.x = my_foo.x};
 189 int PR4517_a[2] = {0, 1};
 190 const int PR4517_ca[2] = {0, 1};
 191 int PR4517_idx = 0;
 192 const int PR4517_idxc = 1;
 193 int PR4517_x1 = PR4517_a[PR4517_idx]; // expected-error {{initializer element is not a compile-time constant}}
 194 int PR4517_x2 = PR4517_a[PR4517_idxc]; // expected-error {{initializer element is not a compile-time constant}}
 195 int PR4517_x3 = PR4517_a[0]; // expected-error {{initializer element is not a compile-time constant}}
 196 int PR4517_y1 = PR4517_ca[PR4517_idx]; // expected-error {{initializer element is not a compile-time constant}}
 197 int PR4517_y2 = PR4517_ca[PR4517_idxc]; // no-warning
 198 int PR4517_y3 = PR4517_ca[0]; // no-warning
 199 union PR4517_u {
 200     int x;
 201     float y;
 202 };
 203 const union PR4517_u u1 = {4.0f};
 204 const union PR4517_u u2 = u1; // no-warning
 205 const union PR4517_u u3 = {u1.y}; // expected-error {{initializer element is not a compile-time constant}}