clang/test/AST/ByteCode/c.c

   1 // RUN: %clang_cc1 -triple x86_64-linux -fexperimental-new-constant-interpreter -verify=expected,all -std=c11 -Wcast-qual %s
   2 // RUN: %clang_cc1 -triple x86_64-linux -fexperimental-new-constant-interpreter -pedantic -verify=pedantic,pedantic-expected,all -std=c11 -Wcast-qual %s
   3 // RUN: %clang_cc1 -triple x86_64-linux -verify=ref,all -std=c11 -Wcast-qual %s
   4 // RUN: %clang_cc1 -triple x86_64-linux -pedantic -verify=pedantic,pedantic-ref,all -std=c11 -Wcast-qual %s
   5
   6 typedef __INTPTR_TYPE__ intptr_t;
   7 typedef __PTRDIFF_TYPE__ ptrdiff_t;
   8
   9 _Static_assert(1, "");
  10
  11 _Static_assert(__objc_yes, "");
  12 _Static_assert(!__objc_no, "");
  13
  14 _Static_assert(0 != 1, "");
  15 _Static_assert(1.0 == 1.0, ""); // pedantic-ref-warning {{not an integer constant expression}} \
  16                                 // pedantic-expected-warning {{not an integer constant expression}}
  17 _Static_assert(1 && 1.0, ""); // pedantic-ref-warning {{not an integer constant expression}} \
  18                               // pedantic-expected-warning {{not an integer constant expression}}
  19 _Static_assert( (5 > 4) + (3 > 2) == 2, "");
  20 _Static_assert(!!1.0, ""); // pedantic-ref-warning {{not an integer constant expression}} \
  21                            // pedantic-expected-warning {{not an integer constant expression}}
  22 _Static_assert(!!1, "");
  23
  24 _Static_assert(!(_Bool){(void*)0}, ""); // pedantic-ref-warning {{not an integer constant expression}} \
  25                                         // pedantic-expected-warning {{not an integer constant expression}}
  26
  27 int a = (1 == 1 ? 5 : 3);
  28 _Static_assert(a == 5, ""); // all-error {{not an integral constant expression}}
  29
  30 const int DiscardedPtrToIntCast = ((intptr_t)((void*)0), 0); // all-warning {{left operand of comma operator has no effect}}
  31
  32 const int b = 3;
  33 _Static_assert(b == 3, ""); // pedantic-ref-warning {{not an integer constant expression}} \
  34                             // pedantic-expected-warning {{not an integer constant expression}}
  35
  36 const int c; // all-note {{declared here}}
  37 _Static_assert(c == 0, ""); // ref-error {{not an integral constant expression}} \
  38                             // ref-note {{initializer of 'c' is unknown}} \
  39                             // pedantic-ref-error {{not an integral constant expression}} \
  40                             // pedantic-ref-note {{initializer of 'c' is unknown}} \
  41                             // expected-error {{not an integral constant expression}} \
  42                             // expected-note {{initializer of 'c' is unknown}} \
  43                             // pedantic-expected-error {{not an integral constant expression}} \
  44                             // pedantic-expected-note {{initializer of 'c' is unknown}}
  45
  46 _Static_assert(&c != 0, ""); // ref-warning {{always true}} \
  47                              // pedantic-ref-warning {{always true}} \
  48                              // pedantic-ref-warning {{is a GNU extension}} \
  49                              // expected-warning {{always true}} \
  50                              // pedantic-expected-warning {{always true}} \
  51                              // pedantic-expected-warning {{is a GNU extension}}
  52 _Static_assert(&a != 0, ""); // ref-warning {{always true}} \
  53                              // pedantic-ref-warning {{always true}} \
  54                              // pedantic-ref-warning {{is a GNU extension}} \
  55                              // expected-warning {{always true}} \
  56                              // pedantic-expected-warning {{always true}} \
  57                              // pedantic-expected-warning {{is a GNU extension}}
  58 _Static_assert((&c + 1) != 0, ""); // pedantic-ref-warning {{is a GNU extension}} \
  59                                    // pedantic-expected-warning {{is a GNU extension}}
  60 _Static_assert((&a + 100) != 0, ""); // pedantic-ref-warning {{is a GNU extension}} \
  61                                      // pedantic-ref-note {{100 of non-array}} \
  62                                      // pedantic-expected-note {{100 of non-array}} \
  63                                      // pedantic-expected-warning {{is a GNU extension}}
  64 _Static_assert((&a - 100) != 0, ""); // pedantic-ref-warning {{is a GNU extension}} \
  65                                      // pedantic-expected-warning {{is a GNU extension}} \
  66                                      // pedantic-ref-note {{-100 of non-array}} \
  67                                      // pedantic-expected-note {{-100 of non-array}}
  68 /// extern variable of a composite type.
  69 extern struct Test50S Test50;
  70 _Static_assert(&Test50 != (void*)0, ""); // all-warning {{always true}} \
  71                                          // pedantic-warning {{is a GNU extension}} \
  72                                          // pedantic-note {{this conversion is not allowed in a constant expression}}
  73
  74 struct y {int x,y;};
  75 int a2[(intptr_t)&((struct y*)0)->y]; // all-warning {{folded to constant array}}
  76
  77 const struct y *yy = (struct y*)0;
  78 const intptr_t L = (intptr_t)(&(yy->y)); // all-error {{not a compile-time constant}}
  79
  80 _Static_assert((long)&((struct y*)0)->y > 0, ""); // pedantic-ref-warning {{GNU extension}} \
  81                                                   // pedantic-ref-note {{this conversion is not allowed in a constant expression}} \
  82                                                   // pedantic-expected-warning {{GNU extension}} \
  83                                                   // pedantic-expected-note {{this conversion is not allowed in a constant expression}}
  84
  85 const ptrdiff_t m = &m + 137 - &m;
  86 _Static_assert(m == 137, ""); // pedantic-ref-warning {{GNU extension}} \
  87                               // pedantic-expected-warning {{GNU extension}}
  88
  89 /// from test/Sema/switch.c, used to cause an assertion failure.
  90 void f (int z) {
  91   while (z) {
  92     default: z--; // all-error {{'default' statement not in switch}}
  93   }
  94 }
  95
  96 int expr;
  97 int chooseexpr[__builtin_choose_expr(1, 1, expr)];
  98
  99 int somefunc(int i) {
 100   return (i, 65537) * 65537; // all-warning {{left operand of comma operator has no effect}} \
 101                              // all-warning {{overflow in expression; result is 131'073 with type 'int'}}
 102 }
 103
 104 #pragma clang diagnostic ignored "-Wpointer-to-int-cast"
 105 struct ArrayStruct {
 106   char n[1];
 107 };
 108 char name2[(int)&((struct ArrayStruct*)0)->n]; // expected-warning {{folded to constant array}} \
 109                                                // pedantic-expected-warning {{folded to constant array}} \
 110                                                // ref-warning {{folded to constant array}} \
 111                                                // pedantic-ref-warning {{folded to constant array}}
 112 _Static_assert(sizeof(name2) == 0, "");
 113
 114 #ifdef __SIZEOF_INT128__
 115 void *PR28739d = &(&PR28739d)[(__int128)(unsigned long)-1]; // all-warning {{refers past the last possible element}}
 116 #endif
 117
 118 extern float global_float;
 119 struct XX { int a, *b; };
 120 struct XY { int before; struct XX xx, *xp; float* after; } xy[] = {
 121   0, 0, &xy[0].xx.a, &xy[0].xx, &global_float,
 122   [1].xx = 0, &xy[1].xx.a, &xy[1].xx, &global_float,
 123   0,              // all-note {{previous initialization is here}}
 124   0,              // all-note {{previous initialization is here}}
 125   [2].before = 0, // all-warning {{initializer overrides prior initialization of this subobject}}
 126   0,              // all-warning {{initializer overrides prior initialization of this subobject}}
 127   &xy[2].xx.a, &xy[2].xx, &global_float
 128 };
 129
 130 void t14(void) {
 131   int array[256] = { 0 }; // expected-note {{array 'array' declared here}} \
 132                           // pedantic-expected-note {{array 'array' declared here}} \
 133                           // ref-note {{array 'array' declared here}} \
 134                           // pedantic-ref-note {{array 'array' declared here}}
 135   const char b = -1;
 136   int val = array[b]; // expected-warning {{array index -1 is before the beginning of the array}} \
 137                       // pedantic-expected-warning {{array index -1 is before the beginning of the array}} \
 138                       // ref-warning {{array index -1 is before the beginning of the array}} \
 139                       // pedantic-ref-warning {{array index -1 is before the beginning of the array}}
 140
 141 }
 142
 143 void bar_0(void) {
 144   struct C {
 145     const int a;
 146     int b;
 147   };
 148
 149   const struct C S = {0, 0};
 150
 151   *(int *)(&S.a) = 0; // all-warning {{cast from 'const int *' to 'int *' drops const qualifier}}
 152   *(int *)(&S.b) = 0; // all-warning {{cast from 'const int *' to 'int *' drops const qualifier}}
 153 }
 154
 155 /// Complex-to-bool casts.
 156 const int A =  ((_Complex double)1.0 ? 21 : 1);
 157 _Static_assert(A == 21, ""); // pedantic-ref-warning {{GNU extension}} \
 158                              // pedantic-expected-warning {{GNU extension}}
 159
 160 const int CTI1 = ((_Complex double){0.0, 1.0}); // pedantic-ref-warning {{extension}} \
 161                                                 // pedantic-expected-warning {{extension}}
 162 _Static_assert(CTI1 == 0, ""); // pedantic-ref-warning {{GNU extension}} \
 163                                // pedantic-expected-warning {{GNU extension}}
 164
 165 const _Bool CTB2 = (_Bool)(_Complex double){0.0, 1.0}; // pedantic-ref-warning {{extension}} \
 166                                                        // pedantic-expected-warning {{extension}}
 167 _Static_assert(CTB2, ""); // pedantic-ref-warning {{GNU extension}} \
 168                           // pedantic-expected-warning {{GNU extension}}
 169
 170 const _Bool CTB3 = (_Complex double){0.0, 1.0}; // pedantic-ref-warning {{extension}} \
 171                                                 // pedantic-expected-warning {{extension}}
 172 _Static_assert(CTB3, ""); // pedantic-ref-warning {{GNU extension}} \
 173                           // pedantic-expected-warning {{GNU extension}}
 174
 175
 176 int t1 = sizeof(int);
 177 void test4(void) {
 178   t1 = sizeof(int);
 179 }
 180
 181 void localCompoundLiteral(void) {
 182   struct S { int x, y; } s = {}; // pedantic-expected-warning {{use of an empty initializer}} \
 183                                  // pedantic-ref-warning {{use of an empty initializer}}
 184   struct T {
 185         int i;
 186     struct S s;
 187   } t1 = { 1, {} }; // pedantic-expected-warning {{use of an empty initializer}} \
 188                     // pedantic-ref-warning {{use of an empty initializer}}
 189
 190   struct T t3 = {
 191     (int){}, // pedantic-expected-warning {{use of an empty initializer}} \
 192              // pedantic-ref-warning {{use of an empty initializer}}
 193     {} // pedantic-expected-warning {{use of an empty initializer}} \
 194        // pedantic-ref-warning {{use of an empty initializer}}
 195   };
 196 }
 197
 198 /// struct copy
 199 struct StrA {int a; };
 200 const struct StrA sa = { 12 };
 201 const struct StrA * const sb = &sa;
 202 const struct StrA sc = *sb;
 203 _Static_assert(sc.a == 12, ""); // pedantic-ref-warning {{GNU extension}} \
 204                                 // pedantic-expected-warning {{GNU extension}}
 205
 206 _Static_assert(((void*)0 + 1) != (void*)0, ""); // pedantic-expected-warning {{arithmetic on a pointer to void is a GNU extension}} \
 207                                                 // pedantic-expected-warning {{not an integer constant expression}} \
 208                                                 // pedantic-expected-note {{cannot perform pointer arithmetic on null pointer}} \
 209                                                 // pedantic-ref-warning {{arithmetic on a pointer to void is a GNU extension}} \
 210                                                 // pedantic-ref-warning {{not an integer constant expression}} \
 211                                                 // pedantic-ref-note {{cannot perform pointer arithmetic on null pointer}}
 212
 213 typedef __INTPTR_TYPE__ intptr_t;
 214 int array[(intptr_t)(int*)1]; // ref-warning {{variable length array folded to constant array}} \
 215                               // pedantic-ref-warning {{variable length array folded to constant array}} \
 216                               // expected-warning {{variable length array folded to constant array}} \
 217                               // pedantic-expected-warning {{variable length array folded to constant array}}
 218
 219 int castViaInt[*(int*)(unsigned long)"test"]; // ref-error {{variable length array}} \
 220                                               // pedantic-ref-error {{variable length array}} \
 221                                               // expected-error {{variable length array}} \
 222                                               // pedantic-expected-error {{variable length array}}
 223
 224 const void (*const funcp)(void) = (void*)123; // pedantic-warning {{converts between void pointer and function pointer}}
 225 _Static_assert(funcp == (void*)0, ""); // all-error {{failed due to requirement 'funcp == (void *)0'}} \
 226                                        // pedantic-warning {{expression is not an integer constant expression}}
 227 _Static_assert(funcp == (void*)123, ""); // pedantic-warning {{equality comparison between function pointer and void pointer}} \
 228                                          // pedantic-warning {{expression is not an integer constant expression}}
 229
 230 void unaryops(void) {
 231   (void)(++(struct x {unsigned x;}){3}.x);
 232   (void)(--(struct y {unsigned x;}){3}.x);
 233   (void)(++(struct z {float x;}){3}.x);
 234   (void)(--(struct w {float x;}){3}.x);
 235
 236   (void)((struct xx {unsigned x;}){3}.x++);
 237   (void)((struct yy {unsigned x;}){3}.x--);
 238   (void)((struct zz {float x;}){3}.x++);
 239   (void)((struct ww {float x;}){3}.x--);
 240 }
 241
 242 /// This used to fail because we didn't properly mark the struct
 243 /// initialized through a CompoundLiteralExpr as initialized.
 244 struct TestStruct {
 245   int a;
 246   int b;
 247 };
 248 int Y __attribute__((annotate(
 249   "GlobalValAnnotationWithArgs",
 250   42,
 251   (struct TestStruct) { .a = 1, .b = 2 }
 252 )));
 253
 254 #ifdef __SIZEOF_INT128__
 255 const int *p = &b;
 256 const __int128 K = (__int128)(int*)0;
 257 const unsigned __int128 KU = (unsigned __int128)(int*)0;
 258 #endif
 259
 260
 261 int test3(void) {
 262   int a[2];
 263   a[0] = test3; // all-error {{incompatible pointer to integer conversion assigning to 'int' from 'int (void)'}}
 264   return 0;
 265 }
 266 /// This tests that we have full type info, even for values we cannot read.
 267 int dummyarray[5];
 268 _Static_assert(&dummyarray[0] < &dummyarray[1], ""); // pedantic-warning {{GNU extension}}
 269
 270 void addrlabelexpr(void) {
 271  a0: ;
 272   static void *ps[] = { &&a0 }; // pedantic-warning {{use of GNU address-of-label extension}}
 273 }
 274
 275 extern void cv2;
 276 void *foo5 (void)
 277 {
 278   return &cv2; // pedantic-warning{{address of an expression of type 'void'}}
 279 }
 280
 281 __attribute__((weak)) const unsigned int test10_bound = 10;
 282 char test10_global[test10_bound]; // all-error {{variable length array declaration not allowed at file scope}}
 283 void test10(void) {
 284   char test10_local[test10_bound] = "help"; // all-error {{variable-sized object may not be initialized}}
 285 }
 286
 287 void SuperSpecialFunc(void) {
 288 const int SuperSpecialCase = 10;
 289 _Static_assert((sizeof(SuperSpecialCase) == 12 && SuperSpecialCase == 3) || SuperSpecialCase == 10, ""); // pedantic-warning {{GNU extension}}
 290 }
 291
 292
 293 void T1(void) {
 294   static int *y[1] = {({ static int _x = 20; (void*)0;})}; // all-error {{initializer element is not a compile-time constant}} \
 295                                                            // pedantic-warning {{use of GNU statement expression extension}}
 296 }
 297
 298 enum teste1 test1f(void), (*test1)(void) = test1f; // pedantic-warning {{ISO C forbids forward references to 'enum' types}}
 299 enum teste1 { TEST1 };
 300
 301 void func(void) {
 302   _Static_assert(func + 1 - func == 1, ""); // pedantic-warning {{arithmetic on a pointer to the function type}} \
 303                                             // pedantic-warning {{arithmetic on pointers to the function type}} \
 304                                             // pedantic-warning {{not an integer constant expression}}
 305   _Static_assert(func + 0xdead000000000000UL - 0xdead000000000000UL == func, ""); // pedantic-warning 2{{arithmetic on a pointer to the function type}} \
 306                                                                                   // pedantic-warning {{not an integer constant expression}} \
 307                                                                                   // pedantic-note {{cannot refer to element 16045481047390945280 of non-array object in a constant expression}}
 308   _Static_assert(func + 1 != func, ""); // pedantic-warning {{arithmetic on a pointer to the function type}} \
 309                                         // pedantic-warning {{expression is not an integer constant expression}}
 310   func + 0xdead000000000000UL; // all-warning {{expression result unused}} \
 311                                // pedantic-warning {{arithmetic on a pointer to the function type}}
 312   func - 0xdead000000000000UL; // all-warning {{expression result unused}} \
 313                                // pedantic-warning {{arithmetic on a pointer to the function type}}
 314 }
 315
 316 void foo3 (void)
 317 {
 318  void* x = 0;
 319  void* y = &*x;
 320 }