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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
// LWG2296 - addressof should be constexpr
// { dg-do run { target c++11 } }
template <typename T>
constexpr inline T *
addressof (T &x) noexcept
{
return __builtin_addressof (x);
}
int i;
static_assert (__builtin_addressof (i) == &i, "");
static_assert (addressof (i) == &i, "");
constexpr int &j = i;
static_assert (__builtin_addressof (j) == &i, "");
static_assert (addressof (j) == &i, "");
struct S { int s; } s;
static_assert (__builtin_addressof (s) == &s, "");
static_assert (addressof (s) == &s, "");
struct T
{
static T tt;
constexpr T () : p (addressof (tt)) {}
constexpr T *operator & () const { return p; }
T *p;
};
constexpr T t;
T T::tt;
static_assert (&t == __builtin_addressof (T::tt), "");
static_assert (&t == addressof (T::tt), "");
struct S x, y;
constexpr S *
foo (bool b)
{
return __builtin_addressof (b ? x : y);
}
constexpr S *
bar (bool b, S &c, S &d)
{
return __builtin_addressof (b ? c : d);
}
static_assert (foo (false) == &y, "");
static_assert (foo (true) == &x, "");
static_assert (bar (false, y, x) == &x, "");
static_assert (bar (true, y, x) == &y, "");
constexpr S *
foo2 (bool b)
{
return addressof (b ? x : y);
}
constexpr S *
bar2 (bool b, S &c, S &d)
{
return addressof (b ? c : d);
}
static_assert (foo2 (false) == &y, "");
static_assert (foo2 (true) == &x, "");
static_assert (bar2 (false, y, x) == &x, "");
static_assert (bar2 (true, y, x) == &y, "");
constexpr int a = 1;
static_assert (__builtin_addressof (a) == &a, "");
static_assert (addressof (a) == &a, "");
constexpr int c[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
void
baz ()
{
}
int
main ()
{
if (__builtin_addressof (T::tt) == __builtin_addressof (t)
|| addressof (T::tt) == addressof (t)
|| &T::tt != &t
|| __builtin_addressof (baz) != baz
|| addressof (baz) != baz)
__builtin_abort ();
// reinterpret casts are not constexprs
if (! (((int *) __builtin_addressof (s) == &s.s)
&& ((int *) addressof (s) == &s.s)
&& (__builtin_addressof (t) == (const T *) &t.p)
&& (addressof (t) == (const T *) &t.p)
&& ((const int *) __builtin_addressof (c) == &c[0])
&& ((const int *) addressof (c) == &c[0])))
__builtin_abort ();
return 0;
}
|
