p2-0x.cpp revision 282e7e66748cc6dd14d6f7f2cb52e5373c531e61 
1// RUN: %clang_cc1 -fsyntax-only -std=c++11 -pedantic -verify -fcxx-exceptions %s -fconstexpr-depth 128 -triple i686-pc-linux-gnu
2
3// A conditional-expression is a core constant expression unless it involves one
4// of the following as a potentially evaluated subexpression [...]:
5
6// - this (5.1.1 [expr.prim.general]) [Note: when evaluating a constant
7//   expression, function invocation substitution (7.1.5 [dcl.constexpr])
8//   replaces each occurrence of this in a constexpr member function with a
9//   pointer to the class object. -end note];
10struct This {
11  int this1 : this1; // expected-error {{undeclared}}
12  int this2 : this->this1; // expected-error {{invalid}}
13  void this3() {
14    int n1[this->this1]; // expected-warning {{variable length array}}
15    int n2[this1]; // expected-warning {{variable length array}}
16    (void)n1, (void)n2;
17  }
18};
19
20// - an invocation of a function other than a constexpr constructor for a
21//   literal class or a constexpr function [ Note: Overload resolution (13.3)
22//   is applied as usual - end note ];
23struct NonConstexpr1 {
24  static int f() { return 1; } // expected-note {{here}}
25  int n : f(); // expected-error {{constant expression}} expected-note {{non-constexpr function 'f' cannot be used in a constant expression}}
26};
27struct NonConstexpr2 {
28  constexpr NonConstexpr2(); // expected-note {{here}}
29  int n;
30};
31struct NonConstexpr3 {
32  NonConstexpr3();
33  int m : NonConstexpr2().n; // expected-error {{constant expression}} expected-note {{undefined constructor 'NonConstexpr2'}}
34};
35struct NonConstexpr4 {
36  NonConstexpr4(); // expected-note {{declared here}}
37  int n;
38};
39struct NonConstexpr5 {
40  int n : NonConstexpr4().n; // expected-error {{constant expression}} expected-note {{non-constexpr constructor 'NonConstexpr4' cannot be used in a constant expression}}
41};
42
43// - an invocation of an undefined constexpr function or an undefined
44//   constexpr constructor;
45struct UndefinedConstexpr {
46  constexpr UndefinedConstexpr();
47  static constexpr int undefinedConstexpr1(); // expected-note {{here}}
48  int undefinedConstexpr2 : undefinedConstexpr1(); // expected-error {{constant expression}} expected-note {{undefined function 'undefinedConstexpr1' cannot be used in a constant expression}}
49};
50
51// - an invocation of a constexpr function with arguments that, when substituted
52//   by function invocation substitution (7.1.5), do not produce a constant
53//   expression;
54namespace NonConstExprReturn {
55  static constexpr const int &id_ref(const int &n) {
56    return n; // expected-note {{reference to temporary cannot be returned from a constexpr function}}
57  }
58  struct NonConstExprFunction {
59    int n : id_ref( // expected-error {{constant expression}} expected-note {{in call to 'id_ref(16)'}}
60        16 // expected-note {{temporary created here}}
61        );
62  };
63  constexpr const int *address_of(const int &a) {
64    return &a; // expected-note {{pointer to 'n' cannot be returned from a constexpr function}}
65  }
66  constexpr const int *return_param(int n) { // expected-note {{declared here}}
67    return address_of(n); // expected-note {{in call to 'address_of(n)'}}
68  }
69  struct S {
70    int n : *return_param(0); // expected-error {{constant expression}} expected-note {{in call to 'return_param(0)'}}
71  };
72}
73
74// - an invocation of a constexpr constructor with arguments that, when
75//   substituted by function invocation substitution (7.1.5), do not produce all
76//   constant expressions for the constructor calls and full-expressions in the
77//   mem-initializers (including conversions);
78namespace NonConstExprCtor {
79  struct T {
80    constexpr T(const int &r) :
81      r(r) { // expected-note 2{{reference to temporary cannot be used to initialize a member in a constant expression}}
82    }
83    const int &r;
84  };
85  constexpr int n = 0;
86  constexpr T t1(n); // ok
87  constexpr T t2(0); // expected-error {{must be initialized by a constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'T(0)'}}
88
89  struct S {
90    int n : T(4).r; // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'T(4)'}}
91  };
92}
93
94// - an invocation of a constexpr function or a constexpr constructor that would
95//   exceed the implementation-defined recursion limits (see Annex B);
96namespace RecursionLimits {
97  constexpr int RecurseForever(int n) {
98    return n + RecurseForever(n+1); // expected-note {{constexpr evaluation exceeded maximum depth of 128 calls}} expected-note 9{{in call to 'RecurseForever(}} expected-note {{skipping 118 calls}}
99  }
100  struct AlsoRecurseForever {
101    constexpr AlsoRecurseForever(int n) :
102      n(AlsoRecurseForever(n+1).n) // expected-note {{constexpr evaluation exceeded maximum depth of 128 calls}} expected-note 9{{in call to 'AlsoRecurseForever(}} expected-note {{skipping 118 calls}}
103    {}
104    int n;
105  };
106  struct S {
107    int k : RecurseForever(0); // expected-error {{constant expression}} expected-note {{in call to}}
108    int l : AlsoRecurseForever(0).n; // expected-error {{constant expression}} expected-note {{in call to}}
109  };
110}
111
112// - an operation that would have undefined behavior [Note: including, for
113//   example, signed integer overflow (Clause 5 [expr]), certain pointer
114//   arithmetic (5.7 [expr.add]), division by zero (5.6 [expr.mul]), or certain
115//   shift operations (5.8 [expr.shift]) -end note];
116namespace UndefinedBehavior {
117  void f(int n) {
118    switch (n) {
119    case (int)4.4e9: // expected-error {{constant expression}} expected-note {{value 4.4E+9 is outside the range of representable values of type 'int'}}
120    case (int)0x80000000u: // ok
121    case (int)10000000000ll: // expected-note {{here}}
122    case (unsigned int)10000000000ll: // expected-error {{duplicate case value}}
123    case (int)(unsigned)(long long)4.4e9: // ok
124    case (int)(float)1e300: // expected-error {{constant expression}} expected-note {{value 1.0E+300 is outside the range of representable values of type 'float'}}
125    case (int)((float)1e37 / 1e30): // ok
126    case (int)(__fp16)65536: // expected-error {{constant expression}} expected-note {{value 65536 is outside the range of representable values of type 'half'}}
127      break;
128    }
129  }
130
131  constexpr int int_min = ~0x7fffffff;
132  constexpr int minus_int_min = -int_min; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}}
133  constexpr int div0 = 3 / 0; // expected-error {{constant expression}} expected-note {{division by zero}} expected-warning {{undefined}}
134  constexpr int mod0 = 3 % 0; // expected-error {{constant expression}} expected-note {{division by zero}} expected-warning {{undefined}}
135  constexpr int int_min_div_minus_1 = int_min / -1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}}
136  constexpr int int_min_mod_minus_1 = int_min % -1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}}
137
138  constexpr int shl_m1 = 0 << -1; // expected-error {{constant expression}} expected-note {{negative shift count -1}} expected-warning {{negative}}
139  constexpr int shl_0 = 0 << 0; // ok
140  constexpr int shl_31 = 0 << 31; // ok
141  constexpr int shl_32 = 0 << 32; // expected-error {{constant expression}} expected-note {{shift count 32 >= width of type 'int' (32}} expected-warning {{>= width of type}}
142  constexpr int shl_unsigned_negative = unsigned(-3) << 1; // ok
143  constexpr int shl_unsigned_into_sign = 1u << 31; // ok
144  constexpr int shl_unsigned_overflow = 1024u << 31; // ok
145  constexpr int shl_signed_negative = (-3) << 1; // expected-error {{constant expression}} expected-note {{left shift of negative value -3}}
146  constexpr int shl_signed_ok = 1 << 30; // ok
147  constexpr int shl_signed_into_sign = 1 << 31; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}}
148  constexpr int shl_signed_overflow = 1024 << 31; // expected-error {{constant expression}} expected-note {{value 2199023255552 is outside the range}} expected-warning {{requires 43 bits to represent}}
149  constexpr int shl_signed_ok2 = 1024 << 20; // ok
150
151  constexpr int shr_m1 = 0 >> -1; // expected-error {{constant expression}} expected-note {{negative shift count -1}} expected-warning {{negative}}
152  constexpr int shr_0 = 0 >> 0; // ok
153  constexpr int shr_31 = 0 >> 31; // ok
154  constexpr int shr_32 = 0 >> 32; // expected-error {{constant expression}} expected-note {{shift count 32 >= width of type}} expected-warning {{>= width of type}}
155
156  struct S {
157    int m;
158  };
159  constexpr S s = { 5 }; // expected-note {{declared here}}
160  constexpr const int *p = &s.m + 1;
161  constexpr const int &f(const int *q) {
162    return q[0]; // expected-note {{dereferenced pointer past the end of subobject of 's' is not a constant expression}}
163  }
164  constexpr int n = (f(p), 0); // expected-error {{constant expression}} expected-note {{in call to 'f(&s.m + 1)'}}
165  struct T {
166    int n : f(p); // expected-error {{not an integral constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
167  };
168
169  namespace Ptr {
170    struct A {};
171    struct B : A { int n; };
172    B a[3][3];
173    constexpr B *p = a[0] + 4; // expected-error {{constant expression}} expected-note {{element 4 of array of 3 elements}}
174    B b = {};
175    constexpr A *pa = &b + 1; // expected-error {{constant expression}} expected-note {{base class of pointer past the end}}
176    constexpr B *pb = (B*)((A*)&b + 1); // expected-error {{constant expression}} expected-note {{derived class of pointer past the end}}
177    constexpr const int *pn = &(&b + 1)->n; // expected-error {{constant expression}} expected-note {{field of pointer past the end}}
178    constexpr B *parr = &a[3][0]; // expected-error {{constant expression}} expected-note {{array element of pointer past the end}}
179
180    constexpr A *na = nullptr;
181    constexpr B *nb = nullptr;
182    constexpr A &ra = *nb; // expected-error {{constant expression}} expected-note {{cannot access base class of null pointer}}
183    constexpr B &rb = (B&)*na; // expected-error {{constant expression}} expected-note {{cannot access derived class of null pointer}}
184    static_assert((A*)nb == 0, "");
185    static_assert((B*)na == 0, "");
186    constexpr const int &nf = nb->n; // expected-error {{constant expression}} expected-note {{cannot access field of null pointer}}
187    constexpr const int &np = (*(int(*)[4])nullptr)[2]; // expected-error {{constant expression}} expected-note {{cannot access array element of null pointer}}
188
189    struct C {
190      constexpr int f() { return 0; }
191    } constexpr c = C();
192    constexpr int k1 = c.f(); // ok
193    constexpr int k2 = ((C*)nullptr)->f(); // expected-error {{constant expression}} expected-note {{cannot call member function on null pointer}}
194    constexpr int k3 = (&c)[1].f(); // expected-error {{constant expression}} expected-note {{cannot call member function on pointer past the end of object}}
195    C c2;
196    constexpr int k4 = c2.f(); // ok!
197
198    constexpr int diff1 = &a[2] - &a[0];
199    constexpr int diff2 = &a[1][3] - &a[1][0];
200    constexpr int diff3 = &a[2][0] - &a[1][0]; // expected-error {{constant expression}} expected-note {{subtracted pointers are not elements of the same array}}
201    static_assert(&a[2][0] == &a[1][3], "");
202    constexpr int diff4 = (&b + 1) - &b;
203    constexpr int diff5 = &a[1][2].n - &a[1][0].n; // expected-error {{constant expression}} expected-note {{subtracted pointers are not elements of the same array}}
204    constexpr int diff6 = &a[1][2].n - &a[1][2].n;
205    constexpr int diff7 = (A*)&a[0][1] - (A*)&a[0][0]; // expected-error {{constant expression}} expected-note {{subtracted pointers are not elements of the same array}}
206  }
207
208  namespace Overflow {
209    // Signed int overflow.
210    constexpr int n1 = 2 * 3 * 3 * 7 * 11 * 31 * 151 * 331; // ok
211    constexpr int n2 = 65536 * 32768; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range of }}
212    constexpr int n3 = n1 + 1; // ok
213    constexpr int n4 = n3 + 1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range of }}
214    constexpr int n5 = -65536 * 32768; // ok
215    constexpr int n6 = 3 * -715827883; // expected-error {{constant expression}} expected-note {{value -2147483649 is outside the range of }}
216    constexpr int n7 = -n3 + -1; // ok
217    constexpr int n8 = -1 + n7; // expected-error {{constant expression}} expected-note {{value -2147483649 is outside the range of }}
218    constexpr int n9 = n3 - 0; // ok
219    constexpr int n10 = n3 - -1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range of }}
220    constexpr int n11 = -1 - n3; // ok
221    constexpr int n12 = -2 - n3; // expected-error {{constant expression}} expected-note {{value -2147483649 is outside the range of }}
222    constexpr int n13 = n5 + n5; // expected-error {{constant expression}} expected-note {{value -4294967296 is outside the range of }}
223    constexpr int n14 = n3 - n5; // expected-error {{constant expression}} expected-note {{value 4294967295 is outside the range of }}
224    constexpr int n15 = n5 * n5; // expected-error {{constant expression}} expected-note {{value 4611686018427387904 is outside the range of }}
225    constexpr signed char c1 = 100 * 2; // ok
226    constexpr signed char c2 = '\x64' * '\2'; // also ok
227    constexpr long long ll1 = 0x7fffffffffffffff; // ok
228    constexpr long long ll2 = ll1 + 1; // expected-error {{constant}} expected-note {{ 9223372036854775808 }}
229    constexpr long long ll3 = -ll1 - 1; // ok
230    constexpr long long ll4 = ll3 - 1; // expected-error {{constant}} expected-note {{ -9223372036854775809 }}
231    constexpr long long ll5 = ll3 * ll3; // expected-error {{constant}} expected-note {{ 85070591730234615865843651857942052864 }}
232
233    // Yikes.
234    char melchizedek[2200000000];
235    typedef decltype(melchizedek[1] - melchizedek[0]) ptrdiff_t;
236    constexpr ptrdiff_t d1 = &melchizedek[0x7fffffff] - &melchizedek[0]; // ok
237    constexpr ptrdiff_t d2 = &melchizedek[0x80000000u] - &melchizedek[0]; // expected-error {{constant expression}} expected-note {{ 2147483648 }}
238    constexpr ptrdiff_t d3 = &melchizedek[0] - &melchizedek[0x80000000u]; // ok
239    constexpr ptrdiff_t d4 = &melchizedek[0] - &melchizedek[0x80000001u]; // expected-error {{constant expression}} expected-note {{ -2147483649 }}
240
241    // Unsigned int overflow.
242    static_assert(65536u * 65536u == 0u, ""); // ok
243    static_assert(4294967295u + 1u == 0u, ""); // ok
244    static_assert(0u - 1u == 4294967295u, ""); // ok
245    static_assert(~0u * ~0u == 1u, ""); // ok
246
247    // Floating-point overflow and NaN.
248    constexpr float f1 = 1e38f * 3.4028f; // ok
249    constexpr float f2 = 1e38f * 3.4029f; // expected-error {{constant expression}} expected-note {{floating point arithmetic produces an infinity}}
250    constexpr float f3 = 1e38f / -.2939f; // ok
251    constexpr float f4 = 1e38f / -.2938f; // expected-error {{constant expression}} expected-note {{floating point arithmetic produces an infinity}}
252    constexpr float f5 = 2e38f + 2e38f; // expected-error {{constant expression}} expected-note {{floating point arithmetic produces an infinity}}
253    constexpr float f6 = -2e38f - 2e38f; // expected-error {{constant expression}} expected-note {{floating point arithmetic produces an infinity}}
254    constexpr float f7 = 0.f / 0.f; // expected-error {{constant expression}} expected-note {{floating point arithmetic produces a NaN}}
255  }
256}
257
258// - a lambda-expression (5.1.2);
259struct Lambda {
260  // FIXME: clang crashes when trying to parse this! Revisit this check once
261  // lambdas are fully implemented.
262  //int n : []{ return 1; }();
263};
264
265// - an lvalue-to-rvalue conversion (4.1) unless it is applied to
266namespace LValueToRValue {
267  // - a non-volatile glvalue of integral or enumeration type that refers to a
268  //   non-volatile const object with a preceding initialization, initialized
269  //   with a constant expression  [Note: a string literal (2.14.5 [lex.string])
270  //   corresponds to an array of such objects. -end note], or
271  volatile const int vi = 1; // expected-note 2{{here}}
272  const int ci = 1;
273  volatile const int &vrci = ci;
274  static_assert(vi, ""); // expected-error {{constant expression}} expected-note {{read of volatile object 'vi'}}
275  static_assert(const_cast<int&>(vi), ""); // expected-error {{constant expression}} expected-note {{read of volatile object 'vi'}}
276  static_assert(vrci, ""); // ok, vrci is converted to a prvalue before
277                           // evaluation and loses its volatility in the
278                           // conversion.
279
280  // - a non-volatile glvalue of literal type that refers to a non-volatile
281  //   object defined with constexpr, or that refers to a sub-object of such an
282  //   object, or
283  struct S {
284    constexpr S(int=0) : i(1), v(1) {}
285    constexpr S(const S &s) : i(2), v(2) {}
286    int i;
287    volatile int v; // expected-note {{here}}
288  };
289  constexpr S s;
290  constexpr volatile S vs; // expected-note 2{{here}}
291  constexpr const volatile S &vrs = s;
292  static_assert(s.i, "");
293  static_assert(s.v, ""); // expected-error {{constant expression}} expected-note {{read of volatile member 'v'}}
294  static_assert(vs.i, ""); // expected-error {{constant expression}} expected-note {{read of volatile object 'vs'}}
295  static_assert(const_cast<int&>(vs.i), ""); // expected-error {{constant expression}} expected-note {{read of volatile object 'vs'}}
296  static_assert(vrs.i, ""); // ok
297
298  // - a non-volatile glvalue of literal type that refers to a non-volatile
299  //   temporary object whose lifetime has not ended, initialized with a
300  //   constant expression;
301  constexpr volatile S f() { return S(); }
302  static_assert(f().i, ""); // ok! there's no lvalue-to-rvalue conversion here!
303  static_assert(((volatile const S&&)(S)0).i, ""); // expected-error {{constant expression}}
304}
305
306// DR1312: The proposed wording for this defect has issues, so we ignore this
307// bullet and instead prohibit casts from pointers to cv void (see core-20842
308// and core-20845).
309//
310// - an lvalue-to-rvalue conversion (4.1 [conv.lval]) that is applied to a
311// glvalue of type cv1 T that refers to an object of type cv2 U, where T and U
312// are neither the same type nor similar types (4.4 [conv.qual]);
313
314// - an lvalue-to-rvalue conversion (4.1) that is applied to a glvalue that
315// refers to a non-active member of a union or a subobject thereof;
316namespace LValueToRValueUnion {
317  // test/SemaCXX/constant-expression-cxx11.cpp contains more thorough testing
318  // of this.
319  union U { int a, b; } constexpr u = U();
320  static_assert(u.a == 0, "");
321  constexpr const int *bp = &u.b;
322  constexpr int b = *bp; // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
323
324  extern const U pu;
325  constexpr const int *pua = &pu.a;
326  constexpr const int *pub = &pu.b;
327  constexpr U pu = { .b = 1 }; // expected-warning {{C99 feature}}
328  constexpr const int a2 = *pua; // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
329  constexpr const int b2 = *pub; // ok
330}
331
332// - an id-expression that refers to a variable or data member of reference type
333//   unless the reference has a preceding initialization, initialized with a
334//   constant expression;
335namespace References {
336  const int a = 2;
337  int &b = *const_cast<int*>(&a);
338  int c = 10; // expected-note 2 {{here}}
339  int &d = c;
340  constexpr int e = 42;
341  int &f = const_cast<int&>(e);
342  extern int &g;
343  constexpr int &h(); // expected-note 2{{here}}
344  int &i = h(); // expected-note {{here}} expected-note {{undefined function 'h' cannot be used in a constant expression}}
345  constexpr int &j() { return b; }
346  int &k = j();
347
348  struct S {
349    int A : a;
350    int B : b;
351    int C : c; // expected-error {{constant expression}} expected-note {{read of non-const variable 'c'}}
352    int D : d; // expected-error {{constant expression}} expected-note {{read of non-const variable 'c'}}
353    int D2 : &d - &c + 1;
354    int E : e / 2;
355    int F : f - 11;
356    int G : g; // expected-error {{constant expression}}
357    int H : h(); // expected-error {{constant expression}} expected-note {{undefined function 'h'}}
358    int I : i; // expected-error {{constant expression}} expected-note {{initializer of 'i' is not a constant expression}}
359    int J : j();
360    int K : k;
361  };
362}
363
364// - a dynamic_cast (5.2.7);
365namespace DynamicCast {
366  struct S { int n; };
367  constexpr S s { 16 };
368  struct T {
369    int n : dynamic_cast<const S*>(&s)->n; // expected-warning {{constant expression}} expected-note {{dynamic_cast}}
370  };
371}
372
373// - a reinterpret_cast (5.2.10);
374namespace ReinterpretCast {
375  struct S { int n; };
376  constexpr S s { 16 };
377  struct T {
378    int n : reinterpret_cast<const S*>(&s)->n; // expected-warning {{constant expression}} expected-note {{reinterpret_cast}}
379  };
380  struct U {
381    int m : (long)(S*)6; // expected-warning {{constant expression}} expected-note {{reinterpret_cast}}
382  };
383}
384
385// - a pseudo-destructor call (5.2.4);
386namespace PseudoDtor {
387  int k;
388  typedef int I;
389  struct T {
390    int n : (k.~I(), 0); // expected-error {{constant expression}}
391  };
392}
393
394// - increment or decrement operations (5.2.6, 5.3.2);
395namespace IncDec {
396  int k = 2;
397  struct T {
398    int n : ++k; // expected-error {{constant expression}}
399    int m : --k; // expected-error {{constant expression}}
400  };
401}
402
403// - a typeid expression (5.2.8) whose operand is of a polymorphic class type;
404namespace std {
405  struct type_info {
406    virtual ~type_info();
407    const char *name;
408  };
409}
410namespace TypeId {
411  struct S { virtual void f(); };
412  constexpr S *p = 0;
413  constexpr const std::type_info &ti1 = typeid(*p); // expected-error {{must be initialized by a constant expression}} expected-note {{typeid applied to expression of polymorphic type 'TypeId::S'}}
414
415  struct T {} t;
416  constexpr const std::type_info &ti2 = typeid(t);
417}
418
419// - a new-expression (5.3.4);
420// - a delete-expression (5.3.5);
421namespace NewDelete {
422  int *p = 0;
423  struct T {
424    int n : *new int(4); // expected-error {{constant expression}}
425    int m : (delete p, 2); // expected-error {{constant expression}}
426  };
427}
428
429// - a relational (5.9) or equality (5.10) operator where the result is
430//   unspecified;
431namespace UnspecifiedRelations {
432  int a, b;
433  constexpr int *p = &a, *q = &b;
434  // C++11 [expr.rel]p2: If two pointers p and q of the same type point to
435  // different objects that are not members of the same array or to different
436  // functions, or if only one of them is null, the results of p<q, p>q, p<=q,
437  // and p>=q are unspecified.
438  constexpr bool u1 = p < q; // expected-error {{constant expression}}
439  constexpr bool u2 = p > q; // expected-error {{constant expression}}
440  constexpr bool u3 = p <= q; // expected-error {{constant expression}}
441  constexpr bool u4 = p >= q; // expected-error {{constant expression}}
442  constexpr bool u5 = p < 0; // expected-error {{constant expression}}
443  constexpr bool u6 = p <= 0; // expected-error {{constant expression}}
444  constexpr bool u7 = p > 0; // expected-error {{constant expression}}
445  constexpr bool u8 = p >= 0; // expected-error {{constant expression}}
446  constexpr bool u9 = 0 < q; // expected-error {{constant expression}}
447  constexpr bool u10 = 0 <= q; // expected-error {{constant expression}}
448  constexpr bool u11 = 0 > q; // expected-error {{constant expression}}
449  constexpr bool u12 = 0 >= q; // expected-error {{constant expression}}
450  void f(), g();
451
452  constexpr void (*pf)() = &f, (*pg)() = &g;
453  constexpr bool u13 = pf < pg; // expected-error {{constant expression}}
454  constexpr bool u14 = pf == pg;
455
456  // If two pointers point to non-static data members of the same object with
457  // different access control, the result is unspecified.
458  struct A {
459  public:
460    constexpr A() : a(0), b(0) {}
461    int a;
462    constexpr bool cmp() { return &a < &b; } // expected-error {{constexpr function never produces a constant expression}} expected-note {{comparison of address of fields 'a' and 'b' of 'A' with differing access specifiers (public vs private) has unspecified value}}
463  private:
464    int b;
465  };
466  class B {
467  public:
468    A a;
469    constexpr bool cmp() { return &a.a < &b.a; } // expected-error {{constexpr function never produces a constant expression}} expected-note {{comparison of address of fields 'a' and 'b' of 'B' with differing access specifiers (public vs protected) has unspecified value}}
470  protected:
471    A b;
472  };
473
474  // If two pointers point to different base sub-objects of the same object, or
475  // one points to a base subobject and the other points to a member, the result
476  // of the comparison is unspecified. This is not explicitly called out by
477  // [expr.rel]p2, but is covered by 'Other pointer comparisons are
478  // unspecified'.
479  struct C {
480    int c[2];
481  };
482  struct D {
483    int d;
484  };
485  struct E : C, D {
486    struct Inner {
487      int f;
488    } e;
489  } e;
490  constexpr bool base1 = &e.c[0] < &e.d; // expected-error {{constant expression}} expected-note {{comparison of addresses of subobjects of different base classes has unspecified value}}
491  constexpr bool base2 = &e.c[1] < &e.e.f; // expected-error {{constant expression}} expected-note {{comparison of address of base class subobject 'C' of class 'E' to field 'e' has unspecified value}}
492  constexpr bool base3 = &e.e.f < &e.d; // expected-error {{constant expression}} expected-note {{comparison of address of base class subobject 'D' of class 'E' to field 'e' has unspecified value}}
493
494  // [expr.rel]p3: Pointers to void can be compared [...] if both pointers
495  // represent the same address or are both the null pointer [...]; otherwise
496  // the result is unspecified.
497  struct S { int a, b; } s;
498  constexpr void *null = 0;
499  constexpr void *pv = (void*)&s.a;
500  constexpr void *qv = (void*)&s.b;
501  constexpr bool v1 = null < 0;
502  constexpr bool v2 = null < pv; // expected-error {{constant expression}}
503  constexpr bool v3 = null == pv; // ok
504  constexpr bool v4 = qv == pv; // ok
505  constexpr bool v5 = qv >= pv; // expected-error {{constant expression}} expected-note {{unequal pointers to void}}
506  constexpr bool v6 = qv > null; // expected-error {{constant expression}}
507  constexpr bool v7 = qv <= (void*)&s.b; // ok
508  constexpr bool v8 = qv > (void*)&s.a; // expected-error {{constant expression}} expected-note {{unequal pointers to void}}
509}
510
511// - an assignment or a compound assignment (5.17); or
512namespace Assignment {
513  int k;
514  struct T {
515    int n : (k = 9); // expected-error {{constant expression}}
516    int m : (k *= 2); // expected-error {{constant expression}}
517  };
518
519  struct Literal {
520    constexpr Literal(const char *name) : name(name) {}
521    const char *name;
522  };
523  struct Expr {
524    constexpr Expr(Literal l) : IsLiteral(true), l(l) {}
525    bool IsLiteral;
526    union {
527      Literal l;
528      // ...
529    };
530  };
531  struct MulEq {
532    constexpr MulEq(Expr a, Expr b) : LHS(a), RHS(b) {}
533    Expr LHS;
534    Expr RHS;
535  };
536  constexpr MulEq operator*=(Expr a, Expr b) { return MulEq(a, b); }
537  Literal a("a");
538  Literal b("b");
539  MulEq c = a *= b; // ok
540}
541
542// - a throw-expression (15.1)
543namespace Throw {
544  struct S {
545    int n : (throw "hello", 10); // expected-error {{constant expression}}
546  };
547}
548
549// PR9999
550template<unsigned int v>
551class bitWidthHolding {
552public:
553  static const
554  unsigned int width = (v == 0 ? 0 : bitWidthHolding<(v >> 1)>::width + 1);
555};
556
557static const int width=bitWidthHolding<255>::width;
558
559template<bool b>
560struct always_false {
561  static const bool value = false;
562};
563
564template<bool b>
565struct and_or {
566  static const bool and_value = b && and_or<always_false<b>::value>::and_value;
567  static const bool or_value = !b || and_or<always_false<b>::value>::or_value;
568};
569
570static const bool and_value = and_or<true>::and_value;
571static const bool or_value = and_or<true>::or_value;
572
573static_assert(and_value == false, "");
574static_assert(or_value == true, "");
575