1// RUN: %clang_cc1 -std=c++1y -verify %s -fcxx-exceptions -triple=x86_64-linux-gnu
2
3struct S {
4  // dummy ctor to make this a literal type
5  constexpr S(int);
6
7  S();
8
9  int arr[10];
10
11  constexpr int &get(int n) { return arr[n]; }
12  constexpr const int &get(int n) const { return arr[n]; }
13};
14
15S s = S();
16const S &sr = s;
17static_assert(&s.get(4) - &sr.get(2) == 2, "");
18
19// Compound-statements can be used in constexpr functions.
20constexpr int e() {{{{}} return 5; }}
21static_assert(e() == 5, "");
22
23// Types can be defined in constexpr functions.
24constexpr int f() {
25  enum E { e1, e2, e3 };
26
27  struct S {
28    constexpr S(E e) : e(e) {}
29    constexpr int get() { return e; }
30    E e;
31  };
32
33  return S(e2).get();
34}
35static_assert(f() == 1, "");
36
37// Variables can be declared in constexpr functions.
38constexpr int g(int k) {
39  const int n = 9;
40  int k2 = k * k;
41  int k3 = k2 * k;
42  return 3 * k3 + 5 * k2 + n * k - 20;
43}
44static_assert(g(2) == 42, "");
45constexpr int h(int n) {
46  static const int m = n; // expected-error {{static variable not permitted in a constexpr function}}
47  return m;
48}
49constexpr int i(int n) {
50  thread_local const int m = n; // expected-error {{thread_local variable not permitted in a constexpr function}}
51  return m;
52}
53
54// if-statements can be used in constexpr functions.
55constexpr int j(int k) {
56  if (k == 5)
57    return 1;
58  if (k == 1)
59    return 5;
60  else {
61    if (int n = 2 * k - 4) {
62      return n + 1;
63      return 2;
64    }
65  }
66} // expected-note 2{{control reached end of constexpr function}}
67static_assert(j(0) == -3, "");
68static_assert(j(1) == 5, "");
69static_assert(j(2), ""); // expected-error {{constant expression}} expected-note {{in call to 'j(2)'}}
70static_assert(j(3) == 3, "");
71static_assert(j(4) == 5, "");
72static_assert(j(5) == 1, "");
73
74// There can be 0 return-statements.
75constexpr void k() {
76}
77
78// If the return type is not 'void', no return statements => never a constant
79// expression, so still diagnose that case.
80[[noreturn]] constexpr int fn() { // expected-error {{no return statement in constexpr function}}
81  fn();
82}
83
84// We evaluate the body of a constexpr constructor, to check for side-effects.
85struct U {
86  constexpr U(int n) {
87    if (j(n)) {} // expected-note {{in call to 'j(2)'}}
88  }
89};
90constexpr U u1{1};
91constexpr U u2{2}; // expected-error {{constant expression}} expected-note {{in call to 'U(2)'}}
92
93// We allow expression-statements.
94constexpr int l(bool b) {
95  if (b)
96    throw "invalid value for b!"; // expected-note {{subexpression not valid}}
97  return 5;
98}
99static_assert(l(false) == 5, "");
100static_assert(l(true), ""); // expected-error {{constant expression}} expected-note {{in call to 'l(true)'}}
101
102// Potential constant expression checking is still applied where possible.
103constexpr int htonl(int x) { // expected-error {{never produces a constant expression}}
104  typedef unsigned char uchar;
105  uchar arr[4] = { uchar(x >> 24), uchar(x >> 16), uchar(x >> 8), uchar(x) };
106  return *reinterpret_cast<int*>(arr); // expected-note {{reinterpret_cast is not allowed in a constant expression}}
107}
108
109constexpr int maybe_htonl(bool isBigEndian, int x) {
110  if (isBigEndian)
111    return x;
112
113  typedef unsigned char uchar;
114  uchar arr[4] = { uchar(x >> 24), uchar(x >> 16), uchar(x >> 8), uchar(x) };
115  return *reinterpret_cast<int*>(arr); // expected-note {{reinterpret_cast is not allowed in a constant expression}}
116}
117
118constexpr int swapped = maybe_htonl(false, 123); // expected-error {{constant expression}} expected-note {{in call}}
119
120namespace NS {
121  constexpr int n = 0;
122}
123constexpr int namespace_alias() {
124  namespace N = NS;
125  return N::n;
126}
127
128namespace assign {
129  constexpr int a = 0;
130  const int b = 0;
131  int c = 0; // expected-note {{here}}
132
133  constexpr void set(const int &a, int b) {
134    const_cast<int&>(a) = b; // expected-note 3{{constant expression cannot modify an object that is visible outside that expression}}
135  }
136  constexpr int wrap(int a, int b) {
137    set(a, b);
138    return a;
139  }
140
141  static_assert((set(a, 1), a) == 1, ""); // expected-error {{constant expression}} expected-note {{in call to 'set(a, 1)'}}
142  static_assert((set(b, 1), b) == 1, ""); // expected-error {{constant expression}} expected-note {{in call to 'set(b, 1)'}}
143  static_assert((set(c, 1), c) == 1, ""); // expected-error {{constant expression}} expected-note {{in call to 'set(c, 1)'}}
144
145  static_assert(wrap(a, 1) == 1, "");
146  static_assert(wrap(b, 1) == 1, "");
147  static_assert(wrap(c, 1) == 1, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'c'}}
148}
149
150namespace string_assign {
151  template<typename T>
152  constexpr void swap(T &a, T &b) {
153    T tmp = a;
154    a = b;
155    b = tmp;
156  }
157  template<typename Iterator>
158  constexpr void reverse(Iterator begin, Iterator end) {
159    while (begin != end && begin != --end)
160      swap(*begin++, *end);
161  }
162  template<typename Iterator1, typename Iterator2>
163  constexpr bool equal(Iterator1 a, Iterator1 ae, Iterator2 b, Iterator2 be) {
164    while (a != ae && b != be)
165      if (*a++ != *b++)
166        return false;
167    return a == ae && b == be;
168  }
169  constexpr bool test1(int n) {
170    char stuff[100] = "foobarfoo";
171    const char stuff2[100] = "oofraboof";
172    reverse(stuff, stuff + n); // expected-note {{cannot refer to element 101 of array of 100 elements}}
173    return equal(stuff, stuff + n, stuff2, stuff2 + n);
174  }
175  static_assert(!test1(1), "");
176  static_assert(test1(3), "");
177  static_assert(!test1(6), "");
178  static_assert(test1(9), "");
179  static_assert(!test1(100), "");
180  static_assert(!test1(101), ""); // expected-error {{constant expression}} expected-note {{in call to 'test1(101)'}}
181
182  // FIXME: We should be able to reject this before it's called
183  constexpr void f() {
184    char foo[10] = { "z" }; // expected-note {{here}}
185    foo[10] = 'x'; // expected-warning {{past the end}} expected-note {{assignment to dereferenced one-past-the-end pointer}}
186  }
187  constexpr int k = (f(), 0); // expected-error {{constant expression}} expected-note {{in call}}
188}
189
190namespace array_resize {
191  constexpr int do_stuff(int k1, int k2) {
192    int arr[1234] = { 1, 2, 3, 4 };
193    arr[k1] = 5; // expected-note {{past-the-end}} expected-note {{cannot refer to element 1235}} expected-note {{cannot refer to element -1}}
194    return arr[k2];
195  }
196  static_assert(do_stuff(1, 2) == 3, "");
197  static_assert(do_stuff(0, 0) == 5, "");
198  static_assert(do_stuff(1233, 1233) == 5, "");
199  static_assert(do_stuff(1233, 0) == 1, "");
200  static_assert(do_stuff(1234, 0) == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
201  static_assert(do_stuff(1235, 0) == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
202  static_assert(do_stuff(-1, 0) == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
203}
204
205namespace potential_const_expr {
206  constexpr void set(int &n) { n = 1; }
207  constexpr int div_zero_1() { int z = 0; set(z); return 100 / z; } // no error
208  constexpr int div_zero_2() { // expected-error {{never produces a constant expression}}
209    int z = 0;
210    return 100 / (set(z), 0); // expected-note {{division by zero}}
211  }
212  int n; // expected-note {{declared here}}
213  constexpr int ref() { // expected-error {{never produces a constant expression}}
214    int &r = n;
215    return r; // expected-note {{read of non-const variable 'n'}}
216  }
217}
218
219namespace subobject {
220  union A { constexpr A() : y(5) {} int x, y; };
221  struct B { A a; };
222  struct C : B {};
223  union D { constexpr D() : c() {} constexpr D(int n) : n(n) {} C c; int n; };
224  constexpr void f(D &d) {
225    d.c.a.y = 3;
226    // expected-note@-1 {{cannot modify an object that is visible outside}}
227    // expected-note@-2 {{assignment to member 'c' of union with active member 'n'}}
228  }
229  constexpr bool check(D &d) { return d.c.a.y == 3; }
230
231  constexpr bool g() { D d; f(d); return d.c.a.y == 3; }
232  static_assert(g(), "");
233
234  D d;
235  constexpr bool h() { f(d); return check(d); } // expected-note {{in call}}
236  static_assert(h(), ""); // expected-error {{constant expression}} expected-note {{in call}}
237
238  constexpr bool i() { D d(0); f(d); return check(d); } // expected-note {{in call}}
239  static_assert(i(), ""); // expected-error {{constant expression}} expected-note {{in call}}
240
241  constexpr bool j() { D d; d.c.a.x = 3; return check(d); } // expected-note {{assignment to member 'x' of union with active member 'y'}}
242  static_assert(j(), ""); // expected-error {{constant expression}} expected-note {{in call}}
243}
244
245namespace lifetime {
246  constexpr int &&id(int &&n) { return static_cast<int&&>(n); }
247  constexpr int &&dead() { return id(0); } // expected-note {{temporary created here}}
248  constexpr int bad() { int &&n = dead(); n = 1; return n; } // expected-note {{assignment to temporary whose lifetime has ended}}
249  static_assert(bad(), ""); // expected-error {{constant expression}} expected-note {{in call}}
250}
251
252namespace const_modify {
253  constexpr int modify(int &n) { return n = 1; } // expected-note 2 {{modification of object of const-qualified type 'const int'}}
254  constexpr int test1() { int k = 0; return modify(k); }
255  constexpr int test2() { const int k = 0; return modify(const_cast<int&>(k)); } // expected-note 2 {{in call}}
256  static_assert(test1() == 1, "");
257  static_assert(test2() == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
258  constexpr int i = test2(); // expected-error {{constant expression}} expected-note {{in call}}
259}
260
261namespace null {
262  constexpr int test(int *p) {
263    return *p = 123; // expected-note {{assignment to dereferenced null pointer}}
264  }
265  static_assert(test(0), ""); // expected-error {{constant expression}} expected-note {{in call}}
266}
267
268namespace incdec {
269  template<typename T> constexpr T &ref(T &&r) { return r; }
270  template<typename T> constexpr T postinc(T &&r) { return (r++, r); }
271  template<typename T> constexpr T postdec(T &&r) { return (r--, r); }
272
273  static_assert(++ref(0) == 1, "");
274  static_assert(ref(0)++ == 0, "");
275  static_assert(postinc(0) == 1, "");
276  static_assert(--ref(0) == -1, "");
277  static_assert(ref(0)-- == 0, "");
278  static_assert(postdec(0) == -1, "");
279
280  constexpr int overflow_int_inc_1 = ref(0x7fffffff)++; // expected-error {{constant}} expected-note {{2147483648}}
281  constexpr int overflow_int_inc_1_ok = ref(0x7ffffffe)++;
282  constexpr int overflow_int_inc_2 = ++ref(0x7fffffff); // expected-error {{constant}} expected-note {{2147483648}}
283  constexpr int overflow_int_inc_2_ok = ++ref(0x7ffffffe);
284
285  // inc/dec on short can't overflow because we promote to int first
286  static_assert(++ref<short>(0x7fff) == (int)0xffff8000u, "");
287  static_assert(--ref<short>(0x8000) == 0x7fff, "");
288
289  // inc on bool sets to true
290  static_assert(++ref(false), ""); // expected-warning {{deprecated}}
291  static_assert(++ref(true), ""); // expected-warning {{deprecated}}
292
293  int arr[10];
294  static_assert(++ref(&arr[0]) == &arr[1], "");
295  static_assert(++ref(&arr[9]) == &arr[10], "");
296  static_assert(++ref(&arr[10]) == &arr[11], ""); // expected-error {{constant}} expected-note {{cannot refer to element 11}}
297  static_assert(ref(&arr[0])++ == &arr[0], "");
298  static_assert(ref(&arr[10])++ == &arr[10], ""); // expected-error {{constant}} expected-note {{cannot refer to element 11}}
299  static_assert(postinc(&arr[0]) == &arr[1], "");
300  static_assert(--ref(&arr[10]) == &arr[9], "");
301  static_assert(--ref(&arr[1]) == &arr[0], "");
302  static_assert(--ref(&arr[0]) != &arr[0], ""); // expected-error {{constant}} expected-note {{cannot refer to element -1}}
303  static_assert(ref(&arr[1])-- == &arr[1], "");
304  static_assert(ref(&arr[0])-- == &arr[0], ""); // expected-error {{constant}} expected-note {{cannot refer to element -1}}
305  static_assert(postdec(&arr[1]) == &arr[0], "");
306
307  int x;
308  static_assert(++ref(&x) == &x + 1, "");
309
310  static_assert(++ref(0.0) == 1.0, "");
311  static_assert(ref(0.0)++ == 0.0, "");
312  static_assert(postinc(0.0) == 1.0, "");
313  static_assert(--ref(0.0) == -1.0, "");
314  static_assert(ref(0.0)-- == 0.0, "");
315  static_assert(postdec(0.0) == -1.0, "");
316
317  static_assert(++ref(1e100) == 1e100, "");
318  static_assert(--ref(1e100) == 1e100, "");
319
320  union U {
321    int a, b;
322  };
323  constexpr int f(U u) {
324    return ++u.b; // expected-note {{increment of member 'b' of union with active member 'a'}}
325  }
326  constexpr int wrong_member = f({0}); // expected-error {{constant}} expected-note {{in call to 'f({.a = 0})'}}
327  constexpr int vol = --ref<volatile int>(0); // expected-error {{constant}} expected-note {{decrement of volatile-qualified}}
328
329  constexpr int incr(int k) {
330    int x = k;
331    if (x++ == 100)
332      return x;
333    return incr(x);
334  }
335  static_assert(incr(0) == 101, "");
336}
337
338namespace compound_assign {
339  constexpr bool test_int() {
340    int a = 3;
341    a += 6;
342    if (a != 9) return false;
343    a -= 2;
344    if (a != 7) return false;
345    a *= 3;
346    if (a != 21) return false;
347    if (&(a /= 10) != &a) return false;
348    if (a != 2) return false;
349    a <<= 3;
350    if (a != 16) return false;
351    a %= 6;
352    if (a != 4) return false;
353    a >>= 1;
354    if (a != 2) return false;
355    a ^= 10;
356    if (a != 8) return false;
357    a |= 5;
358    if (a != 13) return false;
359    a &= 14;
360    if (a != 12) return false;
361    return true;
362  }
363  static_assert(test_int(), "");
364
365  constexpr bool test_float() {
366    float f = 123.;
367    f *= 2;
368    if (f != 246.) return false;
369    if ((f -= 0.5) != 245.5) return false;
370    if (f != 245.5) return false;
371    f /= 0.5;
372    if (f != 491.) return false;
373    f += -40;
374    if (f != 451.) return false;
375    return true;
376  }
377  static_assert(test_float(), "");
378
379  constexpr bool test_ptr() {
380    int arr[123] = {};
381    int *p = arr;
382    if ((p += 4) != &arr[4]) return false;
383    if (p != &arr[4]) return false;
384    p += -1;
385    if (p != &arr[3]) return false;
386    if ((p -= -10) != &arr[13]) return false;
387    if (p != &arr[13]) return false;
388    p -= 11;
389    if (p != &arr[2]) return false;
390    return true;
391  }
392  static_assert(test_ptr(), "");
393
394  template<typename T>
395  constexpr bool test_overflow() {
396    T a = 1;
397    while (a != a / 2)
398      a *= 2; // expected-note {{value 2147483648 is outside the range}} expected-note {{ 9223372036854775808 }} expected-note {{floating point arithmetic produces an infinity}}
399    return true;
400  }
401
402  static_assert(test_overflow<int>(), ""); // expected-error {{constant}} expected-note {{call}}
403  static_assert(test_overflow<unsigned>(), ""); // ok, unsigned overflow is defined
404  static_assert(test_overflow<short>(), ""); // ok, short is promoted to int before multiplication
405  static_assert(test_overflow<unsigned short>(), ""); // ok
406  static_assert(test_overflow<unsigned long long>(), ""); // ok
407  static_assert(test_overflow<long long>(), ""); // expected-error {{constant}} expected-note {{call}}
408  static_assert(test_overflow<float>(), ""); // expected-error {{constant}} expected-note {{call}}
409
410  constexpr short test_promotion(short k) {
411    short s = k;
412    s *= s;
413    return s;
414  }
415  static_assert(test_promotion(100) == 10000, "");
416  static_assert(test_promotion(200) == -25536, "");
417  static_assert(test_promotion(256) == 0, "");
418
419  constexpr const char *test_bounds(const char *p, int o) {
420    return p += o; // expected-note {{element 5 of}} expected-note {{element -1 of}} expected-note {{element 1000 of}}
421  }
422  static_assert(test_bounds("foo", 0)[0] == 'f', "");
423  static_assert(test_bounds("foo", 3)[0] == 0, "");
424  static_assert(test_bounds("foo", 4)[-3] == 'o', "");
425  static_assert(test_bounds("foo" + 4, -4)[0] == 'f', "");
426  static_assert(test_bounds("foo", 5) != 0, ""); // expected-error {{constant}} expected-note {{call}}
427  static_assert(test_bounds("foo", -1) != 0, ""); // expected-error {{constant}} expected-note {{call}}
428  static_assert(test_bounds("foo", 1000) != 0, ""); // expected-error {{constant}} expected-note {{call}}
429}
430
431namespace loops {
432  constexpr int fib_loop(int a) {
433    int f_k = 0, f_k_plus_one = 1;
434    for (int k = 1; k != a; ++k) {
435      int f_k_plus_two = f_k + f_k_plus_one;
436      f_k = f_k_plus_one;
437      f_k_plus_one = f_k_plus_two;
438    }
439    return f_k_plus_one;
440  }
441  static_assert(fib_loop(46) == 1836311903, "");
442
443  constexpr bool breaks_work() {
444    int a = 0;
445    for (int n = 0; n != 100; ++n) {
446      ++a;
447      if (a == 5) continue;
448      if ((a % 5) == 0) break;
449    }
450
451    int b = 0;
452    while (b != 17) {
453      ++b;
454      if (b == 6) continue;
455      if ((b % 6) == 0) break;
456    }
457
458    int c = 0;
459    do {
460      ++c;
461      if (c == 7) continue;
462      if ((c % 7) == 0) break;
463    } while (c != 21);
464
465    return a == 10 && b == 12 & c == 14;
466  }
467  static_assert(breaks_work(), "");
468
469  void not_constexpr();
470  constexpr bool no_cont_after_break() {
471    for (;;) {
472      break;
473      not_constexpr();
474    }
475    while (true) {
476      break;
477      not_constexpr();
478    }
479    do {
480      break;
481      not_constexpr();
482    } while (true);
483    return true;
484  }
485  static_assert(no_cont_after_break(), "");
486
487  constexpr bool cond() {
488    for (int a = 1; bool b = a != 3; ++a) {
489      if (!b)
490        return false;
491    }
492    while (bool b = true) {
493      b = false;
494      break;
495    }
496    return true;
497  }
498  static_assert(cond(), "");
499
500  constexpr int range_for() {
501    int arr[] = { 1, 2, 3, 4, 5 };
502    int sum = 0;
503    for (int x : arr)
504      sum += x;
505    return sum;
506  }
507  static_assert(range_for() == 15, "");
508
509  template<int...N> struct ints {};
510  template<typename A, typename B> struct join_ints;
511  template<int...As, int...Bs> struct join_ints<ints<As...>, ints<Bs...>> {
512    using type = ints<As..., sizeof...(As) + Bs...>;
513  };
514  template<unsigned N> struct make_ints {
515    using type = typename join_ints<typename make_ints<N/2>::type, typename make_ints<(N+1)/2>::type>::type;
516  };
517  template<> struct make_ints<0> { using type = ints<>; };
518  template<> struct make_ints<1> { using type = ints<0>; };
519
520  struct ignore { template<typename ...Ts> constexpr ignore(Ts &&...) {} };
521
522  template<typename T, unsigned N> struct array {
523    constexpr array() : arr{} {}
524    template<typename ...X>
525    constexpr array(X ...x) : arr{} {
526      init(typename make_ints<sizeof...(X)>::type{}, x...);
527    }
528    template<int ...I, typename ...X> constexpr void init(ints<I...>, X ...x) {
529      ignore{arr[I] = x ...};
530    }
531    T arr[N];
532    struct iterator {
533      T *p;
534      constexpr explicit iterator(T *p) : p(p) {}
535      constexpr bool operator!=(iterator o) { return p != o.p; }
536      constexpr iterator &operator++() { ++p; return *this; }
537      constexpr T &operator*() { return *p; }
538    };
539    constexpr iterator begin() { return iterator(arr); }
540    constexpr iterator end() { return iterator(arr + N); }
541  };
542
543  constexpr int range_for_2() {
544    array<int, 5> arr { 1, 2, 3, 4, 5 };
545    int sum = 0;
546    for (int k : arr) {
547      sum += k;
548      if (sum > 8) break;
549    }
550    return sum;
551  }
552  static_assert(range_for_2() == 10, "");
553}
554
555namespace assignment_op {
556  struct A {
557    constexpr A() : n(5) {}
558    int n;
559    struct B {
560      int k = 1;
561      union U {
562        constexpr U() : y(4) {}
563        int x;
564        int y;
565      } u;
566    } b;
567  };
568  constexpr bool testA() {
569    A a, b;
570    a.n = 7;
571    a.b.u.y = 5;
572    b = a;
573    return b.n == 7 && b.b.u.y == 5 && b.b.k == 1;
574  }
575  static_assert(testA(), "");
576
577  struct B {
578    bool assigned = false;
579    constexpr B &operator=(const B&) {
580      assigned = true;
581      return *this;
582    }
583  };
584  struct C : B {
585    B b;
586    int n = 5;
587  };
588  constexpr bool testC() {
589    C c, d;
590    c.n = 7;
591    d = c;
592    c.n = 3;
593    return d.n == 7 && d.assigned && d.b.assigned;
594  }
595  static_assert(testC(), "");
596}
597
598namespace switch_stmt {
599  constexpr int f(char k) {
600    bool b = false;
601    int z = 6;
602    switch (k) {
603      return -1;
604    case 0:
605      if (false) {
606      case 1:
607        z = 1;
608        for (; b;) {
609          return 5;
610          while (0)
611            case 2: return 2;
612          case 7: z = 7;
613          do case 6: {
614            return z;
615            if (false)
616              case 3: return 3;
617            case 4: z = 4;
618          } while (1);
619          case 5: b = true;
620          case 9: z = 9;
621        }
622        return z;
623      } else if (false) case 8: z = 8;
624      else if (false) {
625      case 10:
626        z = -10;
627        break;
628      }
629      else z = 0;
630      return z;
631    default:
632      return -1;
633    }
634    return -z;
635  }
636  static_assert(f(0) == 0, "");
637  static_assert(f(1) == 1, "");
638  static_assert(f(2) == 2, "");
639  static_assert(f(3) == 3, "");
640  static_assert(f(4) == 4, "");
641  static_assert(f(5) == 5, "");
642  static_assert(f(6) == 6, "");
643  static_assert(f(7) == 7, "");
644  static_assert(f(8) == 8, "");
645  static_assert(f(9) == 9, "");
646  static_assert(f(10) == 10, "");
647
648  // Check that we can continue an outer loop from within a switch.
649  constexpr bool contin() {
650    for (int n = 0; n != 10; ++n) {
651      switch (n) {
652      case 0:
653        ++n;
654        continue;
655      case 1:
656        return false;
657      case 2:
658        return true;
659      }
660    }
661    return false;
662  }
663  static_assert(contin(), "");
664
665  constexpr bool switch_into_for() {
666    int n = 0;
667    switch (n) {
668      for (; n == 1; ++n) {
669        return n == 1;
670      case 0: ;
671      }
672    }
673    return false;
674  }
675  static_assert(switch_into_for(), "");
676
677  constexpr void duff_copy(char *a, const char *b, int n) {
678    switch ((n - 1) % 8 + 1) {
679      for ( ; n; n = (n - 1) & ~7) {
680      case 8: a[n-8] = b[n-8];
681      case 7: a[n-7] = b[n-7];
682      case 6: a[n-6] = b[n-6];
683      case 5: a[n-5] = b[n-5];
684      case 4: a[n-4] = b[n-4];
685      case 3: a[n-3] = b[n-3];
686      case 2: a[n-2] = b[n-2];
687      case 1: a[n-1] = b[n-1];
688      }
689      case 0: ;
690    }
691  }
692
693  constexpr bool test_copy(const char *str, int n) {
694    char buffer[16] = {};
695    duff_copy(buffer, str, n);
696    for (int i = 0; i != sizeof(buffer); ++i)
697      if (buffer[i] != (i < n ? str[i] : 0))
698        return false;
699    return true;
700  }
701  static_assert(test_copy("foo", 0), "");
702  static_assert(test_copy("foo", 1), "");
703  static_assert(test_copy("foo", 2), "");
704  static_assert(test_copy("hello world", 0), "");
705  static_assert(test_copy("hello world", 7), "");
706  static_assert(test_copy("hello world", 8), "");
707  static_assert(test_copy("hello world", 9), "");
708  static_assert(test_copy("hello world", 10), "");
709  static_assert(test_copy("hello world", 10), "");
710}
711
712namespace deduced_return_type {
713  constexpr auto f() { return 0; }
714  template<typename T> constexpr auto g(T t) { return t; }
715  static_assert(f() == 0, "");
716  static_assert(g(true), "");
717}
718
719namespace modify_temporary_during_construction {
720  struct A { int &&temporary; int x; int y; };
721  constexpr int f(int &r) { r *= 9; return r - 12; }
722  // FIXME: The 'uninitialized' warning here is bogus.
723  constexpr A a = { 6, f(a.temporary), a.temporary }; // expected-warning {{uninitialized}} expected-note {{temporary created here}}
724  static_assert(a.x == 42, "");
725  static_assert(a.y == 54, "");
726  constexpr int k = a.temporary++; // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
727}
728
729namespace std {
730  typedef decltype(sizeof(int)) size_t;
731
732  template <class _E>
733  class initializer_list
734  {
735    const _E* __begin_;
736    size_t    __size_;
737
738    constexpr initializer_list(const _E* __b, size_t __s)
739      : __begin_(__b),
740        __size_(__s)
741    {}
742
743  public:
744    typedef _E        value_type;
745    typedef const _E& reference;
746    typedef const _E& const_reference;
747    typedef size_t    size_type;
748
749    typedef const _E* iterator;
750    typedef const _E* const_iterator;
751
752    constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
753
754    constexpr size_t    size()  const {return __size_;}
755    constexpr const _E* begin() const {return __begin_;}
756    constexpr const _E* end()   const {return __begin_ + __size_;}
757  };
758}
759
760namespace InitializerList {
761  constexpr int sum(std::initializer_list<int> ints) {
762    int total = 0;
763    for (int n : ints) total += n;
764    return total;
765  }
766  static_assert(sum({1, 2, 3, 4, 5}) == 15, "");
767}
768
769namespace StmtExpr {
770  constexpr int f(int k) {
771    switch (k) {
772    case 0:
773      return 0;
774
775      ({
776        case 1: // expected-note {{not supported}}
777          return 1;
778      });
779    }
780  }
781  static_assert(f(1) == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
782
783  constexpr int g() { // expected-error {{never produces a constant}}
784    return ({ int n; n; }); // expected-note {{object of type 'int' is not initialized}}
785  }
786
787  // FIXME: We should handle the void statement expression case.
788  constexpr int h() { // expected-error {{never produces a constant}}
789    ({ if (true) {} }); // expected-note {{not supported}}
790    return 0;
791  }
792}
793
794namespace VirtualFromBase {
795  struct S1 {
796    virtual int f() const;
797  };
798  struct S2 {
799    virtual int f();
800  };
801  template <typename T> struct X : T {
802    constexpr X() {}
803    double d = 0.0;
804    constexpr int f() { return sizeof(T); }
805  };
806
807  // Non-virtual f(), OK.
808  constexpr X<X<S1>> xxs1;
809  constexpr X<S1> *p = const_cast<X<X<S1>>*>(&xxs1);
810  static_assert(p->f() == sizeof(S1), "");
811
812  // Virtual f(), not OK.
813  constexpr X<X<S2>> xxs2;
814  constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
815  static_assert(q->f() == sizeof(X<S2>), ""); // expected-error {{constant expression}} expected-note {{virtual function call}}
816}
817
818namespace Lifetime {
819  constexpr int &get(int &&r) { return r; }
820  constexpr int f() {
821    int &r = get(123);
822    return r; // expected-note {{read of object outside its lifetime}}
823  }
824  static_assert(f() == 123, ""); // expected-error {{constant expression}} expected-note {{in call}}
825
826  constexpr int g() {
827    int *p = 0;
828    {
829      int n = 0;
830      p = &n;
831      n = 42;
832    }
833    *p = 123; // expected-note {{assignment to object outside its lifetime}}
834    return *p;
835  }
836  static_assert(g() == 42, ""); // expected-error {{constant expression}} expected-note {{in call}}
837
838  constexpr int h(int n) {
839    int *p[4] = {};
840    int &&r = 1;
841    p[0] = &r;
842    while (int a = 1) {
843      p[1] = &a;
844      for (int b = 1; int c = 1; ) {
845        p[2] = &b, p[3] = &c;
846        break;
847      }
848      break;
849    }
850    *p[n] = 0; // expected-note 3{{assignment to object outside its lifetime}}
851    return *p[n];
852  }
853  static_assert(h(0) == 0, ""); // ok, lifetime-extended
854  static_assert(h(1) == 0, ""); // expected-error {{constant expression}} expected-note {{in call}}
855  static_assert(h(2) == 0, ""); // expected-error {{constant expression}} expected-note {{in call}}
856  static_assert(h(3) == 0, ""); // expected-error {{constant expression}} expected-note {{in call}}
857
858  // FIXME: This function should be treated as non-constant.
859  constexpr void lifetime_versus_loops() {
860    int *p = 0;
861    for (int i = 0; i != 2; ++i) {
862      int *q = p;
863      int n = 0;
864      p = &n;
865      if (i)
866        // This modifies the 'n' from the previous iteration of the loop outside
867        // its lifetime.
868        ++*q;
869    }
870  }
871  static_assert((lifetime_versus_loops(), true), "");
872}
873
874namespace Bitfields {
875  struct A {
876    bool b : 3;
877    int n : 4;
878    unsigned u : 5;
879  };
880  constexpr bool test() {
881    A a {};
882    a.b += 2;
883    --a.n;
884    --a.u;
885    a.n = -a.n * 3;
886    return a.b == false && a.n == 3 && a.u == 31;
887  }
888  static_assert(test(), "");
889}
890
891namespace PR17615 {
892  struct A {
893    int &&r;
894    constexpr A(int &&r) : r(static_cast<int &&>(r)) {}
895    constexpr A() : A(0) {
896      (void)+r; // expected-note {{outside its lifetime}}
897    }
898  };
899  constexpr int k = A().r; // expected-error {{constant expression}} expected-note {{in call to}}
900}
901
902namespace PR17331 {
903  template<typename T, unsigned int N>
904  constexpr T sum(const T (&arr)[N]) {
905    T result = 0;
906    for (T i : arr)
907      result += i;
908    return result;
909  }
910
911  constexpr int ARR[] = { 1, 2, 3, 4, 5 };
912  static_assert(sum(ARR) == 15, "");
913}
914