clang/test/Sema/conversion.c

   1 // RUN: %clang_cc1 -fsyntax-only -verify -Wconversion \
   2 // RUN:   -nostdsysteminc -nobuiltininc -isystem %S/Inputs \
   3 // RUN:   -triple x86_64-apple-darwin %s -Wno-unreachable-code
   4
   5 #include <conversion.h>
   6
   7 #define BIG 0x7f7f7f7f7f7f7f7fL
   8
   9 void test0(char c, short s, int i, long l, long long ll) {
  10   c = c;
  11   c = s; // expected-warning {{implicit conversion loses integer precision}}
  12   c = i; // expected-warning {{implicit conversion loses integer precision}}
  13   c = l; // expected-warning {{implicit conversion loses integer precision}}
  14   s = c;
  15   s = s;
  16   s = i; // expected-warning {{implicit conversion loses integer precision}}
  17   s = l; // expected-warning {{implicit conversion loses integer precision}}
  18   i = c;
  19   i = s;
  20   i = i;
  21   i = l; // expected-warning {{implicit conversion loses integer precision}}
  22   l = c;
  23   l = s;
  24   l = i;
  25   l = l;
  26
  27   c = (char) 0;
  28   c = (short) 0;
  29   c = (int) 0;
  30   c = (long) 0;
  31   s = (char) 0;
  32   s = (short) 0;
  33   s = (int) 0;
  34   s = (long) 0;
  35   i = (char) 0;
  36   i = (short) 0;
  37   i = (int) 0;
  38   i = (long) 0;
  39   l = (char) 0;
  40   l = (short) 0;
  41   l = (int) 0;
  42   l = (long) 0;
  43
  44   c = (char) BIG;
  45   c = (short) BIG; // expected-warning {{implicit conversion from 'short' to 'char' changes value}}
  46   c = (int) BIG; // expected-warning {{implicit conversion from 'int' to 'char' changes value}}
  47   c = (long) BIG; // expected-warning {{implicit conversion from 'long' to 'char' changes value}}
  48   s = (char) BIG;
  49   s = (short) BIG;
  50   s = (int) BIG; // expected-warning {{implicit conversion from 'int' to 'short' changes value}}
  51   s = (long) BIG; // expected-warning {{implicit conversion from 'long' to 'short' changes value}}
  52   i = (char) BIG;
  53   i = (short) BIG;
  54   i = (int) BIG;
  55   i = (long) BIG; // expected-warning {{implicit conversion from 'long' to 'int' changes value}}
  56   l = (char) BIG;
  57   l = (short) BIG;
  58   l = (int) BIG;
  59   l = (long) BIG;
  60 }
  61
  62 char test1(long long ll) {
  63   return (long long) ll; // expected-warning {{implicit conversion loses integer precision}}
  64 }
  65 char test1_a(long long ll) {
  66   return (long) ll; // expected-warning {{implicit conversion loses integer precision}}
  67 }
  68 char test1_b(long long ll) {
  69   return (int) ll; // expected-warning {{implicit conversion loses integer precision}}
  70 }
  71 char test1_c(long long ll) {
  72   return (short) ll; // expected-warning {{implicit conversion loses integer precision}}
  73 }
  74 char test1_d(long long ll) {
  75   return (char) ll;
  76 }
  77 char test1_e(long long ll) {
  78   return (long long) BIG; // expected-warning {{implicit conversion from 'long long' to 'char' changes value}}
  79 }
  80 char test1_f(long long ll) {
  81   return (long) BIG; // expected-warning {{implicit conversion from 'long' to 'char' changes value}}
  82 }
  83 char test1_g(long long ll) {
  84   return (int) BIG; // expected-warning {{implicit conversion from 'int' to 'char' changes value}}
  85 }
  86 char test1_h(long long ll) {
  87   return (short) BIG; // expected-warning {{implicit conversion from 'short' to 'char' changes value}}
  88 }
  89 char test1_i(long long ll) {
  90   return (char) BIG;
  91 }
  92
  93 short test2(long long ll) {
  94   return (long long) ll; // expected-warning {{implicit conversion loses integer precision}}
  95 }
  96 short test2_a(long long ll) {
  97   return (long) ll; // expected-warning {{implicit conversion loses integer precision}}
  98 }
  99 short test2_b(long long ll) {
 100   return (int) ll; // expected-warning {{implicit conversion loses integer precision}}
 101 }
 102 short test2_c(long long ll) {
 103   return (short) ll;
 104 }
 105 short test2_d(long long ll) {
 106   return (char) ll;
 107 }
 108 short test2_e(long long ll) {
 109   return (long long) BIG;  // expected-warning {{implicit conversion from 'long long' to 'short' changes value}}
 110 }
 111 short test2_f(long long ll) {
 112   return (long) BIG;  // expected-warning {{implicit conversion from 'long' to 'short' changes value}}
 113 }
 114 short test2_g(long long ll) {
 115   return (int) BIG;  // expected-warning {{implicit conversion from 'int' to 'short' changes value}}
 116 }
 117 short test2_h(long long ll) {
 118   return (short) BIG;
 119 }
 120 short test2_i(long long ll) {
 121   return (char) BIG;
 122 }
 123
 124 int test3(long long ll) {
 125   return (long long) ll;  // expected-warning {{implicit conversion loses integer precision}}
 126 }
 127 int test3_b(long long ll) {
 128   return (long) ll;  // expected-warning {{implicit conversion loses integer precision}}
 129 }
 130 int test3_c(long long ll) {
 131   return (int) ll;
 132 }
 133 int test3_d(long long ll) {
 134   return (short) ll;
 135 }
 136 int test3_e(long long ll) {
 137   return (char) ll;
 138 }
 139 int test3_f(long long ll) {
 140   return (long long) BIG;  // expected-warning {{implicit conversion from 'long long' to 'int' changes value}}
 141 }
 142 int test3_g(long long ll) {
 143   return (long) BIG; // expected-warning {{implicit conversion from 'long' to 'int' changes value}}
 144 }
 145 int test3_h(long long ll) {
 146   return (int) BIG;
 147 }
 148 int test3_i(long long ll) {
 149   return (short) BIG;
 150 }
 151 int test3_j(long long ll) {
 152   return (char) BIG;
 153 }
 154
 155 long test4(long long ll) {
 156   return (long long) ll;
 157 }
 158 long test4_a(long long ll) {
 159   return (long) ll;
 160 }
 161 long test4_b(long long ll) {
 162   return (int) ll;
 163 }
 164 long test4_c(long long ll) {
 165   return (short) ll;
 166 }
 167 long test4_d(long long ll) {
 168   return (char) ll;
 169 }
 170 long test4_e(long long ll) {
 171   return (long long) BIG;
 172 }
 173 long test4_f(long long ll) {
 174   return (long) BIG;
 175 }
 176 long test4_g(long long ll) {
 177   return (int) BIG;
 178 }
 179 long test4_h(long long ll) {
 180   return (short) BIG;
 181 }
 182 long test4_i(long long ll) {
 183   return (char) BIG;
 184 }
 185
 186 long long test5(long long ll) {
 187   return (long long) ll;
 188   return (long) ll;
 189   return (int) ll;
 190   return (short) ll;
 191   return (char) ll;
 192   return (long long) BIG;
 193   return (long) BIG;
 194   return (int) BIG;
 195   return (short) BIG;
 196   return (char) BIG;
 197 }
 198
 199 void takes_char(char);
 200 void takes_short(short);
 201 void takes_int(int);
 202 void takes_long(long);
 203 void takes_longlong(long long);
 204 void takes_float(float);
 205 void takes_double(double);
 206 void takes_longdouble(long double);
 207
 208 void test6(char v) {
 209   takes_char(v);
 210   takes_short(v);
 211   takes_int(v);
 212   takes_long(v);
 213   takes_longlong(v);
 214   takes_float(v);
 215   takes_double(v);
 216   takes_longdouble(v);
 217 }
 218
 219 void test7(short v) {
 220   takes_char(v); // expected-warning {{implicit conversion loses integer precision}}
 221   takes_short(v);
 222   takes_int(v);
 223   takes_long(v);
 224   takes_longlong(v);
 225   takes_float(v);
 226   takes_double(v);
 227   takes_longdouble(v);
 228 }
 229
 230 void test8(int v) {
 231   takes_char(v); // expected-warning {{implicit conversion loses integer precision}}
 232   takes_short(v); // expected-warning {{implicit conversion loses integer precision}}
 233   takes_int(v);
 234   takes_long(v);
 235   takes_longlong(v);
 236   takes_float(v); // expected-warning {{implicit conversion from 'int' to 'float' may lose precision}}
 237   takes_double(v);
 238   takes_longdouble(v);
 239 }
 240
 241 void test9(long v) {
 242   takes_char(v); // expected-warning {{implicit conversion loses integer precision}}
 243   takes_short(v); // expected-warning {{implicit conversion loses integer precision}}
 244   takes_int(v); // expected-warning {{implicit conversion loses integer precision}}
 245   takes_long(v);
 246   takes_longlong(v);
 247   takes_float(v);  // expected-warning {{implicit conversion from 'long' to 'float' may lose precision}}
 248   takes_double(v); // expected-warning {{implicit conversion from 'long' to 'double' may lose precision}}
 249   takes_longdouble(v);
 250 }
 251
 252 void test10(long long v) {
 253   takes_char(v); // expected-warning {{implicit conversion loses integer precision}}
 254   takes_short(v); // expected-warning {{implicit conversion loses integer precision}}
 255   takes_int(v); // expected-warning {{implicit conversion loses integer precision}}
 256   takes_long(v);
 257   takes_longlong(v);
 258   takes_float(v);  // expected-warning {{implicit conversion from 'long long' to 'float' may lose precision}}
 259   takes_double(v); // expected-warning {{implicit conversion from 'long long' to 'double' may lose precision}}
 260   takes_longdouble(v);
 261 }
 262
 263 void test11(float v) {
 264   takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 265   takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 266   takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 267   takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 268   takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 269   takes_float(v);
 270   takes_double(v);
 271   takes_longdouble(v);
 272 }
 273
 274 void test12(double v) {
 275   takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 276   takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 277   takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 278   takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 279   takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 280   takes_float(v); // expected-warning {{implicit conversion loses floating-point precision}}
 281   takes_double(v);
 282   takes_longdouble(v);
 283 }
 284
 285 void test13(long double v) {
 286   takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 287   takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 288   takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 289   takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 290   takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}}
 291   takes_float(v); // expected-warning {{implicit conversion loses floating-point precision}}
 292   takes_double(v); // expected-warning {{implicit conversion loses floating-point precision}}
 293   takes_longdouble(v);
 294 }
 295
 296 void test14(long l) {
 297   // Fine because of the boolean allowlist.
 298   char c;
 299   c = (l == 4);
 300   c = ((l <= 4) && (l >= 0));
 301   c = ((l <= 4) && (l >= 0)) || (l > 20);
 302 }
 303
 304 void test15(char c) {
 305   c = c + 1 + c * 2;
 306   c = (short) c + 1 + c * 2; // expected-warning {{implicit conversion loses integer precision}}
 307 }
 308
 309 // PR 5422
 310 extern void *test16_external;
 311 void test16(void) {
 312   int a = (unsigned long) &test16_external; // expected-warning {{implicit conversion loses integer precision}}
 313 }
 314
 315 // PR 5938
 316 void test17(void) {
 317   union {
 318     unsigned long long a : 8;
 319     unsigned long long b : 32;
 320     unsigned long long c;
 321   } U;
 322
 323   unsigned int x;
 324   x = U.a;
 325   x = U.b;
 326   x = U.c; // expected-warning {{implicit conversion loses integer precision}}
 327 }
 328
 329 // PR 5939
 330 void test18(void) {
 331   union {
 332     unsigned long long a : 1;
 333     unsigned long long b;
 334   } U;
 335
 336   int x;
 337   x = (U.a ? 0 : 1);
 338   x = (U.b ? 0 : 1);
 339 }
 340
 341 // None of these should warn.
 342 unsigned char test19(unsigned long u64) {
 343   unsigned char x1 = u64 & 0xff;
 344   unsigned char x2 = u64 >> 56;
 345
 346   unsigned char mask = 0xee;
 347   unsigned char x3 = u64 & mask;
 348   return x1 + x2 + x3;
 349 }
 350
 351 void test_7631400(void) {
 352   // This should show up despite the caret being inside a macro substitution
 353   char s = LONG_MAX; // expected-warning {{implicit conversion from 'long' to 'char' changes value}}
 354 }
 355
 356 // assertion for compound operators with non-integral RHS
 357 void f7676608(int);
 358 void test_7676608(void) {
 359   float q = 0.7f;
 360   char c = 5;
 361   f7676608(c *= q); // expected-warning {{conversion}}
 362 }
 363
 364 void test_7904686(void) {
 365   const int i = -1;
 366   unsigned u1 = i; // expected-warning {{implicit conversion changes signedness}}
 367   u1 = i; // expected-warning {{implicit conversion changes signedness}}
 368
 369   unsigned u2 = -1; // expected-warning {{implicit conversion changes signedness}}
 370   u2 = -1; // expected-warning {{implicit conversion changes signedness}}
 371 }
 372
 373 // don't warn about conversions required by contexts in system headers
 374 void test_8232669(void) {
 375   unsigned bitset[20];
 376   SETBIT(bitset, 0);
 377
 378   unsigned y = 50;
 379   SETBIT(bitset, y);
 380
 381 #define USER_SETBIT(set,bit) do { int i = bit; set[i/(8*sizeof(set[0]))] |= (1 << (i%(8*sizeof(set)))); } while(0)
 382   USER_SETBIT(bitset, 0); // expected-warning 2 {{implicit conversion changes signedness}}
 383 }
 384
 385 enum E8559831a { E8559831a_val };
 386 enum E8559831b { E8559831b_val };
 387 typedef enum { E8559831c_val } E8559831c;
 388 enum { E8559831d_val } value_d;
 389
 390 void test_8559831_a(enum E8559831a value);
 391 void test_8559831(enum E8559831b value_a, E8559831c value_c) {
 392   test_8559831_a(value_a); // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}
 393   enum E8559831a a1 = value_a; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}
 394   a1 = value_a; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}
 395
 396   test_8559831_a(E8559831b_val); // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}
 397   enum E8559831a a1a = E8559831b_val; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}
 398   a1 = E8559831b_val; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}
 399
 400   test_8559831_a(value_c); // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}}
 401   enum E8559831a a2 = value_c; // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}}
 402   a2 = value_c; // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}}
 403
 404    test_8559831_a(value_d);
 405    enum E8559831a a3 = value_d;
 406    a3 = value_d;
 407 }
 408
 409 void test26(int si, long sl) {
 410   si = sl % sl; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}}
 411   si = sl % si;
 412   si = si % sl;
 413   si = si / sl;
 414   si = sl / si; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}}
 415 }
 416
 417 typedef unsigned short uint16_t;
 418 typedef unsigned int uint32_t;
 419 typedef __attribute__ ((ext_vector_type(16),__aligned__(32))) uint16_t ushort16;
 420 typedef __attribute__ ((ext_vector_type( 8),__aligned__( 32))) uint32_t uint8;
 421
 422 void test27(ushort16 constants) {
 423     uint8 pairedConstants = (uint8) constants;
 424     ushort16 crCbScale = pairedConstants.s4; // expected-warning {{implicit conversion loses integer precision: 'uint32_t' (aka 'unsigned int') to 'ushort16'}}
 425     ushort16 brBias = pairedConstants.s6; // expected-warning {{implicit conversion loses integer precision: 'uint32_t' (aka 'unsigned int') to 'ushort16'}}
 426 }
 427
 428
 429 float double2float_test1(double a) {
 430     return a; // expected-warning {{implicit conversion loses floating-point precision: 'double' to 'float'}}
 431 }
 432
 433 void double2float_test2(double a, float *b) {
 434   *b += a; // expected-warning {{implicit conversion when assigning computation result loses floating-point precision: 'double' to 'float'}}
 435 }
 436
 437 float sinf (float x);
 438 double double2float_test3(double a) {
 439     return sinf(a); // expected-warning {{implicit conversion loses floating-point precision: 'double' to 'float'}}
 440 }
 441
 442 float double2float_test4(double a, float b) {
 443   b -= a; // expected-warning {{implicit conversion when assigning computation result loses floating-point precision: 'double' to 'float'}}
 444   return b;
 445 }