gcc/testsuite/gcc.dg/c11-atomic-3.c

   1 /* Test for _Atomic in C11.  Test of invalid code.  */
   2 /* { dg-do compile } */
   3 /* { dg-options "-std=c11 -pedantic-errors" } */
   4
   5 /* Increment and decrement are invalid for atomic complex types and
   6    atomic pointers to incomplete types, just as for the corresponding
   7    non-atomic types.  Likewise for types on which arithmetic is
   8    invalid.  */
   9 _Atomic _Complex float acf;
  10 void *_Atomic apv;
  11 struct s *_Atomic aps;
  12 _Atomic struct t { char c; } as;
  13
  14 void
  15 func (void)
  16 {
  17   acf++; /* { dg-error "complex types" } */
  18   acf--; /* { dg-error "complex types" } */
  19   ++acf; /* { dg-error "complex types" } */
  20   --acf; /* { dg-error "complex types" } */
  21   apv++; /* { dg-error "wrong type|pointer of type" } */
  22   apv--; /* { dg-error "wrong type|pointer of type" } */
  23   ++apv; /* { dg-error "wrong type|pointer of type" } */
  24   --apv; /* { dg-error "wrong type|pointer of type" } */
  25   aps++; /* { dg-error "pointer to|invalid use of undefined type" } */
  26   aps--; /* { dg-error "pointer to|invalid use of undefined type" } */
  27   ++aps; /* { dg-error "pointer to|invalid use of undefined type" } */
  28   --aps; /* { dg-error "pointer to|invalid use of undefined type" } */
  29   as++; /* { dg-error "wrong type" } */
  30   as--; /* { dg-error "wrong type" } */
  31   ++as; /* { dg-error "wrong type" } */
  32   --as; /* { dg-error "wrong type" } */
  33 }
  34
  35 /* Pointer subtraction and comparisons differing in _Atomic are
  36    invalid where such subtraction and comparisons differing in
  37    qualifiers are valid.  There is no special allowance for equality
  38    comparisons of pointers to atomic void to pointers to object
  39    types.  Likewise for conditional expressions.  */
  40 int *pi;
  41 _Atomic int *pai;
  42 _Atomic void *pav;
  43 int r;
  44
  45 void
  46 func2 (void)
  47 {
  48   r = pai - pi; /* { dg-error "invalid operands" } */
  49   r = pi - pai; /* { dg-error "invalid operands" } */
  50   r = pi < pai; /* { dg-error "distinct pointer types" } */
  51   r = pi > pai; /* { dg-error "distinct pointer types" } */
  52   r = pi <= pai; /* { dg-error "distinct pointer types" } */
  53   r = pi >= pai; /* { dg-error "distinct pointer types" } */
  54   r = pai < pi; /* { dg-error "distinct pointer types" } */
  55   r = pai > pi; /* { dg-error "distinct pointer types" } */
  56   r = pai <= pi; /* { dg-error "distinct pointer types" } */
  57   r = pai >= pi; /* { dg-error "distinct pointer types" } */
  58   r = pav == pi; /* { dg-error "distinct pointer types" } */
  59   r = pav != pi; /* { dg-error "distinct pointer types" } */
  60   r = pi == pav; /* { dg-error "distinct pointer types" } */
  61   r = pi != pav; /* { dg-error "distinct pointer types" } */
  62   (void) (r ? pai : pi); /* { dg-error "pointer type mismatch" } */
  63   (void) (r ? pi : pai); /* { dg-error "pointer type mismatch" } */
  64   (void) (r ? pai : pav); /* { dg-error "pointer type mismatch" } */
  65   (void) (r ? pav : pai); /* { dg-error "pointer type mismatch" } */
  66 }
  67
  68 /* Likewise for pointer assignment.  */
  69 void
  70 func3 (void)
  71 {
  72   pai = pi; /* { dg-error "incompatible pointer type" } */
  73   pi = pai; /* { dg-error "incompatible pointer type" } */
  74   pav = pai; /* { dg-error "incompatible pointer type" } */
  75   pai = pav; /* { dg-error "incompatible pointer type" } */
  76 }
  77
  78 /* Cases that are invalid for normal assignments are just as invalid
  79    (and should not ICE) when the LHS is atomic.  */
  80 void
  81 func4 (void)
  82 {
  83   as = acf; /* { dg-error "incompatible types" } */
  84   apv = as; /* { dg-error "incompatible types" } */
  85   as += 1; /* { dg-error "invalid operands" } */
  86   apv -= 1; /* { dg-error "pointer of type" } */
  87   apv *= 1; /* { dg-error "invalid operands" } */
  88   apv /= 1; /* { dg-error "invalid operands" } */
  89   apv %= 1; /* { dg-error "invalid operands" } */
  90   apv <<= 1; /* { dg-error "invalid operands" } */
  91   apv >>= 1; /* { dg-error "invalid operands" } */
  92   apv &= 1; /* { dg-error "invalid operands" } */
  93   apv ^= 1; /* { dg-error "invalid operands" } */
  94   apv |= 1; /* { dg-error "invalid operands" } */
  95 }
  96
  97 /* We don't allow atomic bit-fields in GCC (implementation-defined
  98    whether they are permitted).  */
  99 struct abf
 100 {
 101   _Atomic int i : 1; /* { dg-error "atomic type" } */
 102   _Atomic int : 0; /* { dg-error "atomic type" } */
 103 };
 104
 105 /* _Atomic (type-name) may not use a name for an array, function,
 106    qualified or atomic type.  */
 107 _Atomic (int [2]) v0; /* { dg-error "array type" } */
 108 _Atomic (void (void)) v1; /* { dg-error "function type" } */
 109 _Atomic (_Atomic int) v2; /* { dg-error "applied to a qualified type" } */
 110 _Atomic (const int) v3; /* { dg-error "applied to a qualified type" } */
 111 _Atomic (volatile int) v4; /* { dg-error "applied to a qualified type" } */
 112 _Atomic (int *restrict) v5; /* { dg-error "applied to a qualified type" } */
 113
 114 /* _Atomic, used as a qualifier, may not be applied to a function or
 115    array type.  */
 116 typedef int arraytype[2];
 117 typedef void functiontype (void);
 118 _Atomic arraytype v6; /* { dg-error "array type" } */
 119 _Atomic arraytype *v7; /* { dg-error "array type" } */
 120 typedef _Atomic arraytype v8; /* { dg-error "array type" } */
 121 int v9 = sizeof (_Atomic arraytype); /* { dg-error "array type" } */
 122 void v10 (_Atomic arraytype parm); /* { dg-error "array type" } */
 123 struct v11 { _Atomic arraytype f; }; /* { dg-error "array type" } */
 124 _Atomic functiontype v12; /* { dg-error "function type" } */
 125 _Atomic functiontype *v13; /* { dg-error "function type" } */
 126 typedef _Atomic functiontype *v14; /* { dg-error "function type" } */
 127 void v15 (_Atomic functiontype parm); /* { dg-error "function type" } */
 128
 129 /* Function parameters, when function types are required to be
 130    compatible, may not differ in the presence of _Atomic.  See
 131    c11-atomic-1.c for corresponding tests where _Atomic matches.  */
 132 void fc0 (int _Atomic); /* { dg-message "previous declaration" } */
 133 void fc0 (int); /* { dg-error "conflicting types" } */
 134 void fc1 (int); /* { dg-message "prototype declaration" } */
 135 void
 136 fc1 (x)
 137      _Atomic int x; /* { dg-error "match prototype" } */
 138 {
 139 }
 140 void
 141 fc2 (x) /* { dg-message "previous definition" } */
 142      _Atomic int x;
 143 {
 144 }
 145 void fc2 (int); /* { dg-error "incompatible type" } */
 146 void fc3 (int); /* { dg-message "prototype declaration" } */
 147 void
 148 fc3 (x)
 149      _Atomic short x; /* { dg-error "match prototype" } */
 150 {
 151 }
 152 void
 153 fc4 (x) /* { dg-message "previous definition" } */
 154      _Atomic short x;
 155 {
 156 }
 157 void fc4 (int); /* { dg-error "incompatible type" } */
 158
 159 /* Arrays of atomic elements cannot be initialized with string
 160    literals.  */
 161 _Atomic char si0[] = ""; /* { dg-error "inappropriate type" } */
 162 _Atomic char si1[] = u8""; /* { dg-error "inappropriate type" } */
 163 _Atomic signed char si2[] = ""; /* { dg-error "inappropriate type" } */
 164 _Atomic signed char si3[] = u8""; /* { dg-error "inappropriate type" } */
 165 _Atomic unsigned char si4[] = ""; /* { dg-error "inappropriate type" } */
 166 _Atomic unsigned char si5[] = u8""; /* { dg-error "inappropriate type" } */
 167 _Atomic __WCHAR_TYPE__ si6[] = L""; /* { dg-error "inappropriate type" } */
 168 _Atomic __CHAR16_TYPE__ si7[] = u""; /* { dg-error "inappropriate type" } */
 169 _Atomic __CHAR32_TYPE__ si8[] = U""; /* { dg-error "inappropriate type" } */
 170
 171 /* Anything that is syntactically a qualifier applied to the (void)
 172    parameter list results in undefined behavior, which we
 173    diagnose.  */
 174 void fv (_Atomic void); /* { dg-error "may not be qualified" } */