clang/test/Sema/exprs.c

   1 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
   2
   3 // PR 8876 - don't warn about trivially unreachable null derefs.  Note that
   4 // we put this here because the reachability analysis only kicks in for
   5 // suppressing false positives when code has no errors.
   6 #define PR8876(err_ptr) do {\
   7     if (err_ptr) *(int*)(err_ptr) = 1;\
   8   } while (0)
   9
  10 #define PR8876_pos(err_ptr) do {\
  11     if (!err_ptr) *(int*)(err_ptr) = 1;\
  12   } while (0)
  13
  14
  15 // Test that we don't report divide-by-zero errors in unreachable code.
  16 // This test should be left as is, as it also tests CFG functionality.
  17 void radar9171946(void) {
  18   if (0) {
  19     0 / (0 ? 1 : 0); // no-warning
  20   }
  21 }
  22
  23 int test_pr8876(void) {
  24   PR8876(0); // no-warning
  25   PR8876_pos(0); // expected-warning{{indirection of non-volatile null pointer will be deleted, not trap}} expected-note{{consider using __builtin_trap() or qualifying pointer with 'volatile'}}
  26   return 0;
  27 }
  28
  29 // PR 8183 - Handle null pointer constants on the left-side of the '&&', and reason about
  30 // this when determining the reachability of the null pointer dereference on the right side.
  31 void pr8183(unsigned long long test)
  32 {
  33   (void)((((void*)0)) && (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000)))));  // no-warning
  34   (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000)))); // expected-warning {{indirection of non-volatile null pointer will be deleted, not trap}} expected-note {{consider using __builtin_trap() or qualifying pointer with 'volatile'}}
  35 }
  36
  37 // PR1966
  38 _Complex double test1(void) {
  39   return __extension__ 1.0if;
  40 }
  41
  42 _Complex double test2(void) {
  43   return 1.0if;    // expected-warning {{imaginary constants are a C2y extension}}
  44 }
  45
  46 void test3(void) {
  47   int x;
  48   (__extension__ x) = 10;
  49 }
  50
  51 void test4(void) {
  52       static int var;
  53       var =+ 5;  // expected-warning {{use of unary operator that may be intended as compound assignment (+=)}}
  54       var =- 5;  // expected-warning {{use of unary operator that may be intended as compound assignment (-=)}}
  55       var = +5;  // no warning when space between the = and +.
  56       var = -5;
  57
  58       var =+5;  // no warning when the subexpr of the unary op has no space before it.
  59       var =-5;
  60
  61 #define FIVE 5
  62       var=-FIVE;  // no warning with macros.
  63       var=-FIVE;
  64 }
  65
  66 void test5(int *X, float *P) {
  67   (float*)X = P;   // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
  68 #define FOO ((float*) X)
  69   FOO = P;   // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
  70 }
  71
  72 void test6(void) {
  73   int X;
  74   X();  // expected-error {{called object type 'int' is not a function or function pointer}}
  75 }
  76
  77 void test7(int *P, _Complex float Gamma) {
  78    P = (P-42) + Gamma*4;  // expected-error {{invalid operands to binary expression ('int *' and '_Complex float')}}
  79 }
  80
  81 int test8(void) {
  82   int i;
  83   __builtin_choose_expr (0, 42, i) = 10;
  84   return i;
  85 }
  86
  87
  88 // PR3386
  89 struct f { int x : 4;  float y[]; };
  90 int test9(struct f *P) {
  91   int R;
  92   R = __alignof(P->x);  // expected-error {{invalid application of 'alignof' to bit-field}}
  93   R = __alignof(P->y);   // ok.
  94   R = sizeof(P->x); // expected-error {{invalid application of 'sizeof' to bit-field}}
  95   __extension__ ({ R = (__typeof__(P->x)) 2; }); // expected-error {{invalid application of 'typeof' to bit-field}}
  96   return R;
  97 }
  98
  99 // PR3562
 100 void test10(int n,...) {
 101   struct S {
 102     double          a[n];  // expected-error {{fields must have a constant size}}
 103   }               s;
 104   double x = s.a[0];  // should not get another error here.
 105 }
 106
 107
 108 #define MYMAX(A,B)    __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })
 109
 110 struct mystruct {int A; };
 111 void test11(struct mystruct P, float F) {
 112   MYMAX(P, F);  // expected-error {{invalid operands to binary expression ('typeof (P)' (aka 'struct mystruct') and 'typeof (F)' (aka 'float'))}}
 113 }
 114
 115 // PR3753
 116 int test12(const char *X) {
 117   return X == "foo";  // expected-warning {{comparison against a string literal is unspecified (use an explicit string comparison function instead)}}
 118 }
 119
 120 int test12b(const char *X) {
 121   return sizeof(X == "foo"); // no-warning
 122 }
 123
 124 void test13(
 125             void (^P)(void)) { // expected-error {{blocks support disabled - compile with -fblocks}}
 126   P();
 127   P = ^(void){}; // expected-error {{blocks support disabled - compile with -fblocks}}
 128 }
 129
 130 void test14(void) {
 131   typedef long long __m64 __attribute__((__vector_size__(8)));
 132   typedef short __v4hi __attribute__((__vector_size__(8)));
 133
 134   // Ok.
 135   __v4hi a;
 136   __m64 mask = (__m64)((__v4hi)a > (__v4hi)a);
 137 }
 138
 139
 140 // PR5242
 141 typedef unsigned long *test15_t;
 142
 143 test15_t test15(void) {
 144   return (test15_t)0 + (test15_t)0;  // expected-error {{invalid operands to binary expression ('test15_t' (aka 'unsigned long *') and 'test15_t')}}
 145 }
 146
 147 void test16(float x) { x == ((void*) 0); }  // expected-error {{invalid operands to binary expression}}
 148
 149 // PR6004
 150 void test17(int x) {
 151   x = x / 0;  // expected-warning {{division by zero is undefined}}
 152   x = x % 0;  // expected-warning {{remainder by zero is undefined}}
 153   x /= 0;  // expected-warning {{division by zero is undefined}}
 154   x %= 0;  // expected-warning {{remainder by zero is undefined}}
 155
 156   x = sizeof(x/0);  // no warning.
 157 }
 158
 159 // PR6501, PR11857, and PR23564
 160 void test18_a(int a); // expected-note 2 {{'test18_a' declared here}}
 161 void test18_b(int); // expected-note {{'test18_b' declared here}}
 162 void test18_c(int a, int b); // expected-note 2 {{'test18_c' declared here}}
 163 void test18_d(int a, ...); // expected-note {{'test18_d' declared here}}
 164 void test18_e(int a, int b, ...); // expected-note {{'test18_e' declared here}}
 165 #define MY_EXPORT __attribute__((visibility("default")))
 166 MY_EXPORT void // (no "declared here" notes on this line, no "expanded from MY_EXPORT" notes either)
 167 test18_f(int a, int b); // expected-note 2 {{'test18_f' declared here}}
 168 void test18(int b) {
 169   test18_a(b, b); // expected-error {{too many arguments to function call, expected single argument 'a', have 2}}
 170   test18_a(); // expected-error {{too few arguments to function call, single argument 'a' was not specified}}
 171   test18_b(); // expected-error {{too few arguments to function call, expected 1, have 0}}
 172   test18_c(b); // expected-error {{too few arguments to function call, expected 2, have 1}}
 173   test18_c(b, b, b); // expected-error {{too many arguments to function call, expected 2, have 3}}
 174   test18_d(); // expected-error {{too few arguments to function call, at least argument 'a' must be specified}}
 175   test18_e(); // expected-error {{too few arguments to function call, expected at least 2, have 0}}
 176   test18_f(b); // expected-error {{too few arguments to function call, expected 2, have 1}}
 177   test18_f(b, b, b); // expected-error {{too many arguments to function call, expected 2, have 3}}
 178 }
 179
 180 typedef int __attribute__((address_space(256))) int_AS256;
 181 // PR7569
 182 void test19(void) {
 183   *(int *)0 = 0;                                     // expected-warning {{indirection of non-volatile null pointer}} \
 184                   // expected-note {{consider using __builtin_trap}}
 185   *(volatile int *)0 = 0;                            // Ok.
 186   *(int __attribute__((address_space(256))) *)0 = 0; // Ok.
 187   *(int __attribute__((address_space(0))) *)0 = 0;   // expected-warning {{indirection of non-volatile null pointer}} \
 188                      // expected-note {{consider using __builtin_trap}}
 189   *(int_AS256 *)0 = 0;                               // Ok.
 190
 191   int x = *(int *)0;                                                                          // expected-warning {{indirection of non-volatile null pointer}} \
 192                      // expected-note {{consider using __builtin_trap}}
 193   int x2 = *(volatile int *)0;                                                                // Ok.
 194   int x3 = *(int __attribute__((address_space(0))) *)0;                                       // expected-warning {{indirection of non-volatile null pointer}} \
 195                      // expected-note {{consider using __builtin_trap}}
 196   int x4 = *(int_AS256 *)0;                                                                   // Ok.
 197   int *p = &(*(int *)0);                                                                      // Ok.
 198   int_AS256 *p1 = &(*(int __attribute__((address_space(256))) *)0);                           // Ok.
 199   int __attribute__((address_space(0))) *p2 = &(*(int __attribute__((address_space(0))) *)0); // Ok.
 200 }
 201
 202 int test20(int x) {
 203   return x && 4; // expected-warning {{use of logical '&&' with constant operand}} \
 204                  // expected-note {{use '&' for a bitwise operation}} \
 205                  // expected-note {{remove constant to silence this warning}}
 206
 207   return x && sizeof(int) == 4;  // no warning, RHS is logical op.
 208
 209   // no warning, this is an idiom for "true" in old C style.
 210   return x && (signed char)1;
 211
 212   return x || 0;
 213   return x || 1;
 214   return x || -1; // expected-warning {{use of logical '||' with constant operand}} \
 215                   // expected-note {{use '|' for a bitwise operation}}
 216   return x || 5; // expected-warning {{use of logical '||' with constant operand}} \
 217                  // expected-note {{use '|' for a bitwise operation}}
 218   return x && 0;
 219   return x && 1;
 220   return x && -1; // expected-warning {{use of logical '&&' with constant operand}} \
 221                   // expected-note {{use '&' for a bitwise operation}} \
 222                   // expected-note {{remove constant to silence this warning}}
 223   return x && 5; // expected-warning {{use of logical '&&' with constant operand}} \
 224                  // expected-note {{use '&' for a bitwise operation}} \
 225                  // expected-note {{remove constant to silence this warning}}
 226   return x || (0);
 227   return x || (1);
 228   return x || (-1); // expected-warning {{use of logical '||' with constant operand}} \
 229                     // expected-note {{use '|' for a bitwise operation}}
 230   return x || (5); // expected-warning {{use of logical '||' with constant operand}} \
 231                    // expected-note {{use '|' for a bitwise operation}}
 232   return x && (0);
 233   return x && (1);
 234   return x && (-1); // expected-warning {{use of logical '&&' with constant operand}} \
 235                     // expected-note {{use '&' for a bitwise operation}} \
 236                     // expected-note {{remove constant to silence this warning}}
 237   return x && (5); // expected-warning {{use of logical '&&' with constant operand}} \
 238                    // expected-note {{use '&' for a bitwise operation}} \
 239                    // expected-note {{remove constant to silence this warning}}
 240
 241 }
 242
 243 struct Test21; // expected-note 2 {{forward declaration}}
 244 void test21(volatile struct Test21 *ptr) {
 245   void test21_help(void);
 246   (test21_help(), *ptr); // expected-error {{incomplete type 'struct Test21' where a complete type is required}}
 247   (*ptr, test21_help()); // expected-error {{incomplete type 'struct Test21' where a complete type is required}}
 248 }
 249
 250 // Make sure we do function/array decay.
 251 void test22(void) {
 252   if ("help")
 253     (void) 0;
 254
 255   if (test22) // expected-warning {{address of function 'test22' will always evaluate to 'true'}} \
 256               // expected-note {{prefix with the address-of operator to silence this warning}}
 257     (void) 0;
 258
 259   if (&test22)
 260     (void) 0;
 261 }