1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
// RUN: %clang_cc1 -std=c2y %s -verify -Wno-gnu-alignof-expression
/* WG14 N3244: Partial
* Slay Some Earthly Demons I
*
* NB: the committee adopted:
* Annex J Item 21 (including additional change) -- no, we lack explicit documentation
* Annex J Item 56 -- yes
* Annex J Item 57 Option 1 -- yes
* Annex J Item 67 -- no
* Annex J Item 69 (alternative wording for semantics) -- no
*/
void reg_array(void) {
// Decay of an array with the register storage class specifier has gone from
// explicit undefined behavior to be implementation defined instead. Clang
// does not support this.
register int array[10];
(void)sizeof(array); // okay
int *vp = array; // expected-error {{address of register variable requested}}
int val = array[0]; // expected-error {{address of register variable requested}}
}
struct F; // expected-note {{forward declaration of 'struct F'}}
void incomplete_no_linkage(struct F); // okay
void incomplete_no_linkage(struct F f) { // expected-error {{variable has incomplete type 'struct F'}}
struct G g; // expected-error {{variable has incomplete type 'struct G'}} \
expected-note {{forward declaration of 'struct G'}}
int i[]; // expected-error {{definition of variable with array type needs an explicit size or an initializer}}
}
void block_scope_non_extern_func_decl(void) {
static void f(void); // expected-error {{function declared in block scope cannot have 'static' storage class}}
extern void g(void); // okay
__private_extern__ void h(void); // okay
}
// FIXME: this function should be diagnosed as it is never defined in the TU.
extern inline void never_defined_extern_inline(void);
// While this declaration is fine because the function is defined within the TU.
extern inline void is_defined_extern_inline(void);
extern inline void is_defined_extern_inline(void) {}
int NoAlignmentOnOriginalDecl;
// FIXME: the original declaration has no alignment specifier, so the
// declaration below should be diagnosed due to the incompatible alignment
// specifier.
_Alignas(8) int NoAlignmentOnOriginalDecl;
_Static_assert(_Alignof(NoAlignmentOnOriginalDecl) == 8, "");
_Alignas(8) int AlignmentOnOriginalDecl; // expected-note {{declared with '_Alignas' attribute here}}
// FIXME: this should be accepted because the redeclaration has no alignment
// specifier.
int AlignmentOnOriginalDecl; // expected-error {{'_Alignas' must be specified on definition if it is specified on any declaration}}
_Static_assert(_Alignof(AlignmentOnOriginalDecl) == 8, "");
long long CompatibleAlignment;
_Static_assert(_Alignof(__typeof__(CompatibleAlignment)) == _Alignof(long long), "");
_Alignas(_Alignof(long long)) long long CompatibleAlignment; // Okay, alignment is the same as the implied alignment
_Alignas(_Alignof(long long)) long long CompatibleAlignment2; // expected-note {{declared with '_Alignas' attribute here}}
// FIXME: this should be accepted because the redeclaration has no alignment
// specifier.
long long CompatibleAlignment2; // expected-error {{'_Alignas' must be specified on definition if it is specified on any declaration}}
// FIXME: this should be accepted because the definition specifies the
// alignment and a subsequent declaration does not specify any alignment.
_Alignas(8) long long DefnWithInit = 12; // expected-note {{declared with '_Alignas' attribute here}}
long long DefnWithInit; // expected-error {{'_Alignas' must be specified on definition if it is specified on any declaration}}
// This is accepted because the definition has an alignment specifier and the
// subsequent redeclaration does not specify an alignment.
_Alignas(8) long long DefnWithInit2 = 12;
extern long long DefnWithInit2;
// FIXME: this should be accepted because the definition specifies the
// alignment and a subsequent declaration specifies a compatible alignment.
long long DefnWithInit3 = 12; // expected-error {{'_Alignas' must be specified on definition if it is specified on any declaration}}
_Alignas(_Alignof(long long)) long long DefnWithInit3; // expected-note {{declared with '_Alignas' attribute here}}
_Alignas(8) int Mismatch; // expected-note {{previous declaration is here}}
_Alignas(16) int Mismatch; // expected-error {{redeclaration has different alignment requirement (16 vs 8)}}
|
