clang/test/C/drs/dr0xx.c

   1 /* RUN: %clang_cc1 -std=c89 -fsyntax-only -verify=expected,c89only -pedantic -Wno-declaration-after-statement -Wno-c11-extensions %s
   2    RUN: %clang_cc1 -std=c89 -fsyntax-only -verify=expected,c89only -pedantic -Wno-declaration-after-statement -Wno-c11-extensions -fno-signed-char %s
   3    RUN: %clang_cc1 -std=c99 -fsyntax-only -verify=expected,c99untilc2x -pedantic -Wno-c11-extensions %s
   4    RUN: %clang_cc1 -std=c11 -fsyntax-only -verify=expected,c99untilc2x -pedantic %s
   5    RUN: %clang_cc1 -std=c17 -fsyntax-only -verify=expected,c99untilc2x -pedantic %s
   6    RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=expected,c2xandup -pedantic %s
   7  */
   8
   9 /* The following are DRs which do not require tests to demonstrate
  10  * conformance or nonconformance.
  11  *
  12  * WG14 DR001: yes
  13  * Do functions return values by copying?
  14  *
  15  * WG14 DR005: yes
  16  * May a conforming implementation define and recognize a pragma which would
  17  * change the semantics of the language?
  18  *
  19  * WG14 DR008: yes
  20  * Can a conforming C compiler to perform dead-store elimination?
  21  *
  22  * WG14 DR020: yes
  23  * Is a compiler which allows the Relaxed Ref/Def linkage model to be
  24  * considered a conforming compiler?
  25  *
  26  * WG14 DR025: yes
  27  * What is meant by 'representable floating-point value?'
  28  *
  29  * WG14 DR026: yes
  30  * Can a strictly conforming program contain a string literal with '$' or '@'?
  31  *
  32  * WG14 DR033: yes
  33  * Conformance questions around 'shall' violations outside of constraints
  34  * sections
  35  *
  36  * WG14 DR036: yes
  37  * May floating-point constants be represented with more precision than implied
  38  * by its type?
  39  *
  40  * WG14 DR037: yes
  41  * Questions about multibyte characters and Unicode
  42  *
  43  * WG14 DR051: yes
  44  * Question on pointer arithmetic
  45  *
  46  * WG14 DR052: yes
  47  * Editorial corrections
  48  *
  49  * WG14 DR056: yes
  50  * Floating-point representation precision requirements
  51  *
  52  * WG14 DR057: yes
  53  * Is there an integral type for every pointer?
  54  *
  55  * WG14 DR059: yes
  56  * Do types have to be completed?
  57  *
  58  * WG14 DR063: dup 056
  59  * Floating-point representation precision requirements
  60  *
  61  * WG14 DR067: yes
  62  * Integer and integral type confusion
  63  *
  64  * WG14 DR069: yes
  65  * Questions about the representation of integer types
  66  *
  67  * WG14 DR077: yes
  68  * Stability of addresses
  69  *
  70  * WG14 DR080: yes
  71  * Merging of string constants
  72  *
  73  * WG14 DR085: yes
  74  * Returning from main
  75  *
  76  * WG14 DR086: yes
  77  * Object-like macros in system headers
  78  *
  79  * WG14 DR091: yes
  80  * Multibyte encodings
  81  *
  82  * WG14 DR092: dup 060
  83  * Partial initialization of strings
  84  *
  85  * WG14 DR093: yes
  86  * Reservation of identifiers
  87  */
  88
  89
  90 /* WG14 DR004: yes
  91  * Are multiple definitions of unused identifiers with external linkage
  92  * permitted?
  93  */
  94 int dr004(void) {return 0;} /* expected-note {{previous definition is here}} */
  95 int dr004(void) {return 1;} /* expected-error {{redefinition of 'dr004'}} */
  96
  97 /* WG14 DR007: yes
  98  * Are declarations of the form struct-or-union identifier ; permitted after
  99  * the identifier tag has already been declared?
 100  */
 101 struct dr007_a;
 102 struct dr007_a;
 103 struct dr007_a {int a;};
 104 struct dr007_a;
 105 struct dr007_b {int a;};
 106 struct dr007_b;
 107
 108
 109 /* WG14 DR009: no
 110  * Use of typedef names in parameter declarations
 111  *
 112  * FIXME: This should be diagnosed as expecting a declaration specifier instead
 113  * of treated as declaring a parameter of type 'int (*)(dr009_t);'
 114  */
 115 typedef int dr009_t;
 116 void dr009_f((dr009_t)); /* c99untilc2x-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
 117                             c2xandup-error {{a type specifier is required for all declarations}} */
 118
 119 /* WG14 DR010:
 120  * Is a typedef to an incomplete type legal?
 121  */
 122 typedef int dr010_t[];
 123 dr010_t dr010_a = {1};
 124 dr010_t dr010_b = {1, 2};
 125 int dr010_c = sizeof(dr010_t); /* expected-error {{invalid application of 'sizeof' to an incomplete type 'dr010_t' (aka 'int[]')}} */
 126
 127 /* WG14 DR011: yes
 128  * Merging of declarations for linked identifier
 129  *
 130  * Note: more of this DR is tested in dr011.c
 131  *
 132  * WG14 DR034: yes
 133  * External declarations in different scopes
 134  *
 135  * Note: DR034 has a question resolved by DR011 and another question where the
 136  * result is UB.
 137  */
 138 static int dr011_a[]; /* expected-warning {{tentative array definition assumed to have one element}} */
 139 void dr011(void) {
 140   extern int i[];
 141   {
 142     /* a different declaration of the same object */
 143     extern int i[10];
 144     (void)sizeof(i);
 145     _Static_assert(sizeof(i) == 10 * sizeof(int), "fail");
 146   }
 147   (void)sizeof(i); /* expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} */
 148
 149   extern int dr011_a[10];
 150   (void)sizeof(dr011_a);
 151   _Static_assert(sizeof(dr011_a) == 10 * sizeof(int), "fail");
 152
 153   extern int j[10];
 154   {
 155     extern int j[];
 156     (void)sizeof(j);
 157     _Static_assert(sizeof(j) == 10 * sizeof(int), "fail");
 158   }
 159 }
 160
 161 /* WG14 DR012: yes
 162  * Is it valid to take the address of a dereferenced void pointer?
 163  */
 164 void dr012(void *p) {
 165   /* The behavior changed between C89 and C99. */
 166   (void)&*p; /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}}
 167                 c89only-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
 168 }
 169
 170 /* WG14 DR013: yes
 171  * Compatible and composite function types
 172  */
 173 int dr013(int a[4]);
 174 int dr013(int a[5]);
 175 int dr013(int *a);
 176
 177 struct dr013_t {
 178 struct dr013_t *p;
 179 } dr013_v[sizeof(struct dr013_t)];
 180
 181 /* WG14 DR015: yes
 182  * What is the promoted type of a plain int bit-field?
 183  */
 184 void dr015(void) {
 185   struct S {
 186     int small_int_bitfield : 16;
 187     unsigned int small_uint_bitfield : 16;
 188     int int_bitfield : 32;
 189     unsigned int uint_bitfield : 32;
 190   } s;
 191   _Static_assert(__builtin_types_compatible_p(__typeof__(+s.small_int_bitfield), int), "fail");
 192   _Static_assert(__builtin_types_compatible_p(__typeof__(+s.small_uint_bitfield), int), "fail");
 193   _Static_assert(__builtin_types_compatible_p(__typeof__(+s.int_bitfield), int), "fail");
 194   _Static_assert(__builtin_types_compatible_p(__typeof__(+s.uint_bitfield), unsigned int), "fail");
 195 }
 196
 197 /* WG14 DR027: yes
 198  * Can there be characters in the character set that are not in the required
 199  * source character set?
 200  */
 201 #define THIS$AND$THAT(a, b) ((a) + (b)) /* expected-warning 2 {{'$' in identifier}} */
 202 _Static_assert(THIS$AND$THAT(1, 1) == 2, "fail"); /* expected-warning 2 {{'$' in identifier}} */
 203
 204
 205 /* WG14 DR029: no
 206  * Do two types have to have the same tag to be compatible?
 207  * Note: the rule changed in C99 to be different than the resolution to DR029,
 208  * so it's not clear there's value in implementing this DR.
 209  */
 210 _Static_assert(__builtin_types_compatible_p(struct S { int a; }, union U { int a; }), "fail"); /* expected-error {{static assertion failed due to requirement '__builtin_types_compatible_p(struct S, union U)': fail}} */
 211
 212 /* WG14 DR031: yes
 213  * Can constant expressions overflow?
 214  */
 215 void dr031(int i) {
 216   switch (i) {
 217   case __INT_MAX__ + 1: break; /* expected-warning {{overflow in expression; result is -2147483648 with type 'int'}} */
 218   #pragma clang diagnostic push
 219   #pragma clang diagnostic ignored "-Wswitch"
 220   /* Silence the targets which issue:
 221    * warning: overflow converting case value to switch condition type (2147483649 to 18446744071562067969)
 222    */
 223   case __INT_MAX__ + 2ul: break;
 224   #pragma clang diagnostic pop
 225   case (__INT_MAX__ * 4) / 4: break; /* expected-warning {{overflow in expression; result is -4 with type 'int'}} */
 226   }
 227 }
 228
 229 /* WG14 DR032: no
 230  * Must implementations diagnose extensions to the constant evaluation rules?
 231  *
 232  * This should issue a diagnostic because a constant-expression is a
 233  * conditional-expression, which excludes the comma operator.
 234  */
 235 int dr032 = (1, 2); /* expected-warning {{left operand of comma operator has no effect}} */
 236
 237 #if __STDC_VERSION__ < 202311L
 238 /* WG14 DR035: partial
 239  * Questions about definition of functions without a prototype
 240  */
 241 void dr035_1(a, b) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C23}} */
 242   int a(enum b {x, y}); /* expected-warning {{declaration of 'enum b' will not be visible outside of this function}} */
 243   int b; {
 244   int test = x; /* expected-error {{use of undeclared identifier 'x'}} */
 245 }
 246
 247 void dr035_2(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C23}} */
 248   enum m{q, r} c; { /* expected-warning {{declaration of 'enum m' will not be visible outside of this function}} */
 249   /* FIXME: This should be accepted because the scope of m, q, and r ends at
 250    * the closing brace of the function per C89 6.1.2.1.
 251    */
 252   int test = q; /* expected-error {{use of undeclared identifier 'q'}} */
 253 }
 254 #endif /* __STDC_VERSION__ < 202311L */
 255
 256 /* WG14 DR038: yes
 257  * Questions about argument substitution during macro expansion
 258  */
 259 #define DR038_X 0x000E
 260 #define DR038_Y 0x0100
 261 #define DR038(a) a
 262 _Static_assert(DR038(DR038_X + DR038_Y) == DR038_X + DR038_Y, "fail");
 263
 264 /* WG14 DR039: yes
 265  * Questions about the "C" locale
 266  */
 267 _Static_assert(sizeof('a') == sizeof(int), "fail");
 268
 269 /* WG14 DR040: partial
 270  * 9 unrelated questions about C89
 271  *
 272  * Question 6
 273  */
 274 struct dr040 { /* expected-note {{definition of 'struct dr040' is not complete until the closing '}'}} */
 275   char c;
 276   short s;
 277   int i[__builtin_offsetof(struct dr040, s)]; /* expected-error {{offsetof of incomplete type 'struct dr040'}} */
 278 };
 279
 280 /* WG14 DR043: yes
 281  * On the definition of the NULL macro
 282  */
 283 void dr043(void) {
 284   #include <stddef.h>
 285   /* NULL has to be an integer constant expression with the value 0, or such an
 286    * expression cast to void *. If it's an integer constant expression other
 287    * than the literal 0 (such as #define NULL 4-4), this would fail to compile
 288    * unless the macro replacement list is properly parenthesized as it would
 289    * expand to: (void)(void *)4-4;
 290    */
 291    (void)(void *)NULL;
 292
 293   /* If the NULL macro is an integer constant expression with the value 0 and
 294    * it has been cast to void *, ensure that it's also fully parenthesized. If
 295    * it isn't (such as #define NULL (void *)0), this would fail to compile as
 296    * would expand to (void *)0->a; which gives a diagnostic about int not being
 297    * a pointer, instead of((void *)0)->a; which gives a diagnostic about the
 298    * base reference being void and not a structure.
 299    */
 300    NULL->a; /* expected-error {{member reference base type 'void' is not a structure or union}} */
 301 }
 302
 303 /* WG14 DR044: yes
 304  * On the result of the offsetof macro
 305  */
 306 void dr044(void) {
 307   #include <stddef.h>
 308   struct S { int a, b; };
 309   /* Ensure that the result of offsetof is usable in a constant expression. */
 310   _Static_assert(offsetof(struct S, b) == sizeof(int), "fail");
 311 }
 312
 313 /* WG14 DR046: yes
 314  * Use of typedef names in parameter declarations
 315  */
 316 typedef int dr046_t;
 317 int dr046(int dr046_t) { return dr046_t; }
 318
 319 /* WG14 DR047: yes
 320  * Questions about declaration conformance
 321  */
 322 struct dr047_t; /* expected-note 2 {{forward declaration of 'struct dr047_t'}} */
 323 struct dr047_t *dr047_1(struct dr047_t *p) {return p; }
 324 struct dr047_t *dr047_2(struct dr047_t a[]) {return a; } /* expected-error {{array has incomplete element type 'struct dr047_t'}} */
 325 int *dr047_3(int a2[][]) {return *a2; } /* expected-error {{array has incomplete element type 'int[]'}} */
 326 extern struct dr047_t es1;
 327 extern struct dr047_t es2[1]; /* expected-error {{array has incomplete element type 'struct dr047_t'}} */
 328
 329 /* WG14 DR050: yes
 330  * Do wide string literals implicitly include <stddef.h>?
 331  */
 332 void dr050(void) {
 333   /* The NULL macro is previously defined because we include <stddef.h> for
 334    * other tests. Undefine the macro to demonstrate that use of a wide string
 335    * literal doesn't magically include the header file.
 336    */
 337   #undef NULL
 338   (void)L"huttah!";
 339   (void)NULL; /* expected-error {{use of undeclared identifier 'NULL'}} */
 340 }
 341
 342 #if __STDC_VERSION__ < 202311L
 343 /* WG14 DR053: yes
 344  * Accessing a pointer to a function with a prototype through a pointer to
 345  * pointer to function without a prototype
 346  */
 347 void dr053(void) {
 348   int f(int);
 349   int (*fp1)(int);
 350   int (*fp2)();  /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
 351   int (**fpp)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
 352
 353   fp1 = f;
 354   fp2 = fp1;
 355   (*fp2)(3);  /* expected-warning {{passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C23}} */
 356   fpp = &fp1;
 357   (**fpp)(3); /* expected-warning {{passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C23}} */
 358 }
 359 #endif /* __STDC_VERSION__ < 202311L */
 360
 361 /* WG14 DR064: yes
 362  * Null pointer constants
 363  */
 364 char *dr064_1(int i, int *pi) {
 365   *pi = i;
 366   return 0;
 367 }
 368
 369 char *dr064_2(int i, int *pi) {
 370   return (*pi = i, 0); /* expected-error {{incompatible integer to pointer conversion returning 'int' from a function with result type 'char *'}} */
 371 }
 372
 373 /* WG14 DR068: yes
 374  * 'char' and signed vs unsigned integer types
 375  */
 376 void dr068(void) {
 377   #include <limits.h>
 378
 379 #if CHAR_MAX == SCHAR_MAX
 380   /* char is signed */
 381   _Static_assert('\xFF' == -1, "fail");
 382 #else
 383   /* char is unsigned */
 384   _Static_assert('\xFF' == 0xFF, "fail");
 385 #endif
 386 }
 387
 388 #if __STDC_VERSION__ < 202311L
 389 /* WG14: DR070: yes
 390  * Interchangeability of function arguments
 391  *
 392  * Note: we could issue a pedantic warning in this case. We are claiming
 393  * conformance not because we diagnose the UB when we could but because we're
 394  * not obligated to do anything about it and we make it "just work" via the
 395  * usual conversion rules.
 396  *
 397  * This behavior is specific to functions without prototypes. A function with
 398  * a prototype causes implicit conversions rather than relying on default
 399  * argument promotion and warm thoughts.
 400  */
 401 void dr070_1(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C23}} */
 402   int c; {
 403 }
 404
 405 void dr070_2(void) {
 406   dr070_1(6);
 407   dr070_1(6U); /* Pedantically UB */
 408 }
 409 #endif /* __STDC_VERSION__ < 202311L */
 410
 411 /* WG14 DR071: yes
 412  * Enumerated types
 413  */
 414 enum dr071_t { foo_A = 0, foo_B = 1, foo_C = 8 };
 415 void dr071(void) {
 416   /* Test that in-range values not present in the enumeration still round-trip
 417    * to the original value.
 418    */
 419   _Static_assert(100 == (int)(enum dr071_t)100, "fail");
 420 }
 421
 422 /* WG14 DR081: yes
 423  * Left shift operator
 424  */
 425 void dr081(void) {
 426   /* Demonstrate that we don't crash when left shifting a signed value; that's
 427    * implementation defined behavior.
 428    */
 429  _Static_assert(-1 << 1 == -2, "fail"); /* Didn't shift a zero into the "sign bit". */
 430  _Static_assert(1 << 3 == 1u << 3u, "fail"); /* Shift of a positive signed value does sensible things. */
 431 }
 432
 433 /* WG14 DR084: yes
 434  * Incomplete type in function declaration
 435  *
 436  * Note: because the situation is UB, we're free to do what we want. We elect
 437  * to accept and require the incomplete type to be completed before the
 438  * function definition.
 439  */
 440 struct dr084_t; /* expected-note {{forward declaration of 'struct dr084_t'}} */
 441 extern void (*dr084_1)(struct dr084_t);
 442 void dr084_2(struct dr084_t);
 443 void dr084_2(struct dr084_t val) {} /* expected-error {{variable has incomplete type 'struct dr084_t'}} */
 444
 445 /* WG14 DR088: yes
 446  * Compatibility of incomplete types
 447  */
 448 struct dr088_t_1;
 449
 450 void dr088_f(struct dr088_t_1 *); /* expected-note {{passing argument to parameter here}} */
 451 void dr088_1(void) {
 452   /* Distinct type from the file scope forward declaration. */
 453   struct dr088_t_1;
 454   /* FIXME: this diagnostic could be improved to not be utterly baffling. */
 455   dr088_f((struct dr088_t_1 *)0); /* expected-warning {{incompatible pointer types passing 'struct dr088_t_1 *' to parameter of type 'struct dr088_t_1 *'}} */
 456 }
 457
 458 void dr088_2(struct dr088_t_1 *p) { /* Pointer to incomplete type. */ }
 459 struct dr088_t_1 { int i; }; /* Type is completed. */
 460 void dr088_3(struct dr088_t_1 s) {
 461   /* When passing a pointer to the completed type, is it the same type as the
 462    * incomplete type used in the call declaration?
 463    */
 464   dr088_2(&s);
 465 }
 466
 467 /* WG14 DR089: yes
 468  * Multiple definitions of macros
 469  */
 470 #define DR089 object_like             /* expected-note {{previous definition is here}} */
 471 #define DR089(argument) function_like /* expected-warning {{'DR089' macro redefined}} */
 472
 473 /* WG14 DR095: yes
 474  * Is initialization as constrained as assignment?
 475  */
 476 void dr095(void) {
 477   /* Ensure that type compatibility constraints on assignment are also honored
 478    * for initializations.
 479    */
 480   struct One {
 481     int a;
 482   } one;
 483   struct Two {
 484     float f;
 485   } two = one; /* expected-error {{initializing 'struct Two' with an expression of incompatible type 'struct One'}} */
 486
 487   two = one; /* expected-error {{assigning to 'struct Two' from incompatible type 'struct One'}} */
 488 }
 489
 490 /* WG14 DR096: yes
 491  * Arrays of incomplete types
 492  */
 493 void dr096(void) {
 494   typedef void func_type(void);
 495   func_type array_funcs[10]; /* expected-error {{'array_funcs' declared as array of functions of type 'func_type' (aka 'void (void)')}} */
 496
 497   void array_void[10]; /* expected-error {{array has incomplete element type 'void'}} */
 498
 499   struct S; /* expected-note {{forward declaration of 'struct S'}} */
 500   struct S s[10]; /* expected-error {{array has incomplete element type 'struct S'}} */
 501
 502   union U; /* expected-note {{forward declaration of 'union U'}} */
 503   union U u[10]; /* expected-error {{array has incomplete element type 'union U'}} */
 504   union U { int i; };
 505
 506   int never_completed_incomplete_array[][]; /* expected-error {{array has incomplete element type 'int[]'}} */
 507
 508   extern int completed_later[][]; /* expected-error {{array has incomplete element type 'int[]'}} */
 509   extern int completed_later[10][10];
 510 }
 511
 512 /* WG14 DR098: yes
 513  * Pre/post increment/decrement of function or incomplete types
 514  */
 515 void dr098(void) {
 516   typedef void func_type(void);
 517   func_type fp;
 518   struct incomplete *incomplete_ptr;
 519
 520   ++fp; /* expected-error {{cannot increment value of type 'func_type' (aka 'void (void)')}} */
 521   fp++; /* expected-error {{cannot increment value of type 'func_type' (aka 'void (void)')}} */
 522   --fp; /* expected-error {{cannot decrement value of type 'func_type' (aka 'void (void)')}} */
 523   fp--; /* expected-error {{cannot decrement value of type 'func_type' (aka 'void (void)')}} */
 524
 525   (*incomplete_ptr)++; /* expected-error {{cannot increment value of type 'struct incomplete'}} */
 526   ++(*incomplete_ptr); /* expected-error {{cannot increment value of type 'struct incomplete'}} */
 527   (*incomplete_ptr)--; /* expected-error {{cannot decrement value of type 'struct incomplete'}} */
 528   --(*incomplete_ptr); /* expected-error {{cannot decrement value of type 'struct incomplete'}} */
 529 }