| // { dg-do compile { target c++11 } } |
| |
| template <typename To, typename From> |
| constexpr To |
| bit_cast (const From &from) |
| { |
| return __builtin_bit_cast (To, from); |
| } |
| |
| template <typename To, typename From> |
| constexpr bool |
| check (const From &from) |
| { |
| return bit_cast <From> (bit_cast <To> (from)) == from; |
| } |
| |
| struct A |
| { |
| int a, b, c; |
| constexpr bool operator == (const A &x) const |
| { |
| return x.a == a && x.b == b && x.c == c; |
| } |
| }; |
| |
| struct B |
| { |
| unsigned a[3]; |
| constexpr bool operator == (const B &x) const |
| { |
| return x.a[0] == a[0] && x.a[1] == a[1] && x.a[2] == a[2]; |
| } |
| }; |
| |
| struct C |
| { |
| char a[2][3][2]; |
| constexpr bool operator == (const C &x) const |
| { |
| return x.a[0][0][0] == a[0][0][0] |
| && x.a[0][0][1] == a[0][0][1] |
| && x.a[0][1][0] == a[0][1][0] |
| && x.a[0][1][1] == a[0][1][1] |
| && x.a[0][2][0] == a[0][2][0] |
| && x.a[0][2][1] == a[0][2][1] |
| && x.a[1][0][0] == a[1][0][0] |
| && x.a[1][0][1] == a[1][0][1] |
| && x.a[1][1][0] == a[1][1][0] |
| && x.a[1][1][1] == a[1][1][1] |
| && x.a[1][2][0] == a[1][2][0] |
| && x.a[1][2][1] == a[1][2][1]; |
| } |
| }; |
| |
| struct D |
| { |
| int a, b; |
| constexpr bool operator == (const D &x) const |
| { |
| return x.a == a && x.b == b; |
| } |
| }; |
| |
| struct E {}; |
| struct F { char c, d, e, f; }; |
| struct G : public D, E, F |
| { |
| int g; |
| constexpr bool operator == (const G &x) const |
| { |
| return x.a == a && x.b == b && x.c == c && x.d == d |
| && x.e == e && x.f == f && x.g == g; |
| } |
| }; |
| |
| struct H |
| { |
| int a, b[2], c; |
| constexpr bool operator == (const H &x) const |
| { |
| return x.a == a && x.b[0] == b[0] && x.b[1] == b[1] && x.c == c; |
| } |
| }; |
| |
| #if __SIZEOF_INT__ == 4 |
| struct I |
| { |
| int a; |
| int b : 3; |
| int c : 24; |
| int d : 5; |
| int e; |
| constexpr bool operator == (const I &x) const |
| { |
| return x.a == a && x.b == b && x.c == c && x.d == d && x.e == e; |
| } |
| }; |
| #endif |
| |
| #if __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8 |
| struct J |
| { |
| long long int a, b : 11, c : 3, d : 37, e : 1, f : 10, g : 2, h; |
| constexpr bool operator == (const J &x) const |
| { |
| return x.a == a && x.b == b && x.c == c && x.d == d && x.e == e |
| && x.f == f && x.g == g && x.h == h; |
| } |
| }; |
| |
| struct K |
| { |
| long long int a, b, c; |
| constexpr bool operator == (const K &x) const |
| { |
| return x.a == a && x.b == b && x.c == c; |
| } |
| }; |
| |
| struct M |
| { |
| signed a : 6, b : 7, c : 6, d : 5; |
| unsigned char e; |
| unsigned int f; |
| long long int g; |
| constexpr bool operator == (const M &x) const |
| { |
| return x.a == a && x.b == b && x.c == c && x.d == d && x.e == e |
| && x.f == f && x.g == g; |
| } |
| }; |
| |
| struct N |
| { |
| unsigned long long int a, b; |
| constexpr bool operator == (const N &x) const |
| { |
| return x.a == a && x.b == b; |
| } |
| }; |
| #endif |
| |
| static_assert (check <unsigned int> (0), ""); |
| static_assert (check <long long int> (0xdeadbeeffeedbac1ULL), ""); |
| static_assert (check <signed char> ((unsigned char) 42), ""); |
| static_assert (check <char> ((unsigned char) 42), ""); |
| static_assert (check <unsigned char> ((unsigned char) 42), ""); |
| static_assert (check <signed char> ((signed char) 42), ""); |
| static_assert (check <char> ((signed char) 42), ""); |
| static_assert (check <unsigned char> ((signed char) 42), ""); |
| static_assert (check <signed char> ((char) 42), ""); |
| static_assert (check <char> ((char) 42), ""); |
| static_assert (check <unsigned char> ((char) 42), ""); |
| #if __SIZEOF_INT__ == __SIZEOF_FLOAT__ |
| static_assert (check <int> (2.5f), ""); |
| static_assert (check <unsigned int> (136.5f), ""); |
| #endif |
| #if __SIZEOF_LONG_LONG__ == __SIZEOF_DOUBLE__ |
| static_assert (check <long long> (2.5), ""); |
| static_assert (check <long long unsigned> (123456.75), ""); |
| #endif |
| |
| static_assert (check <B> (A{ 1, 2, 3 }), ""); |
| static_assert (check <A> (B{ 4, 5, 6 }), ""); |
| |
| #if __SIZEOF_INT__ == 4 |
| static_assert (check <C> (A{ 7, 8, 9 }), ""); |
| static_assert (check <C> (B{ 10, 11, 12 }), ""); |
| static_assert (check <A> (C{ { { { 13, 14 }, { 15, 16 }, { 17, 18 } }, |
| { { 19, 20 }, { 21, 22 }, { 23, 24 } } } }), ""); |
| constexpr unsigned char c[] = { 1, 2, 3, 4 }; |
| #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
| static_assert (bit_cast <unsigned int> (c) == 0x04030201U, ""); |
| #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
| static_assert (bit_cast <unsigned int> (c) == 0x01020304U, ""); |
| #endif |
| |
| #if __cplusplus >= 201703L |
| static_assert (check <G> (H { 0x12345678, { 0x23456789, 0x5a876543 }, 0x3ba78654 }), ""); |
| #endif |
| constexpr int d[] = { 0x12345678, 0x23456789, 0x5a876543, 0x3ba78654 }; |
| static_assert (bit_cast <G> (d) == bit_cast <G> (H { 0x12345678, { 0x23456789, 0x5a876543 }, 0x3ba78654 }), ""); |
| |
| #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
| static_assert (bit_cast <I> (A { 0x7efa3412, 0x5a876543, 0x1eeffeed }) |
| == I { 0x7efa3412, 3, 0x50eca8, 0xb, 0x1eeffeed }, ""); |
| static_assert (bit_cast <A> (I { 0x7efa3412, 3, 0x50eca8, 0xb, 0x1eeffeed }) |
| == A { 0x7efa3412, 0x5a876543, 0x1eeffeed }, ""); |
| #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
| static_assert (bit_cast <I> (A { 0x7efa3412, 0x5a876543, 0x1eeffeed }) |
| == I { 0x7efa3412, 2, -0x2bc4d6, 0x3, 0x1eeffeed }, ""); |
| static_assert (bit_cast <A> (I { 0x7efa3412, 2, -0x2bc4d6, 0x3, 0x1eeffeed }) |
| == A { 0x7efa3412, 0x5a876543, 0x1eeffeed }, ""); |
| #endif |
| #endif |
| |
| #if 2 * __SIZEOF_INT__ == __SIZEOF_LONG_LONG__ && __SIZEOF_INT__ >= 4 |
| constexpr unsigned long long a = 0xdeadbeeffee1deadULL; |
| constexpr unsigned b[] = { 0xfeedbacU, 0xbeeffeedU }; |
| #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
| static_assert (bit_cast <D> (a) == D { int (0xfee1deadU), int (0xdeadbeefU) }, ""); |
| static_assert (bit_cast <unsigned long long> (b) == 0xbeeffeed0feedbacULL, ""); |
| #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
| static_assert (bit_cast <D> (a) == D { int (0xdeadbeefU), int (0xfee1deadU) }, ""); |
| static_assert (bit_cast <unsigned long long> (b) == 0x0feedbacbeeffeedULL, ""); |
| #endif |
| #endif |
| |
| #if __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8 |
| #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
| static_assert (bit_cast <J> (K { 0x0feedbacdeadbeefLL, 7862463375103529997LL, 0x0feedbacdeadbeefLL }) |
| == J { 0x0feedbacdeadbeefLL, -1011, 2, -0xbacdeadbeLL, -1, -303, 1, 0x0feedbacdeadbeefLL }, ""); |
| static_assert (bit_cast <K> (J { 0x0feedbacdeadbeefLL, -1011, 2, -0xbacdeadbeLL, -1, -303, 1, 0x0feedbacdeadbeefLL }) |
| == K { 0x0feedbacdeadbeefLL, 7862463375103529997LL, 0x0feedbacdeadbeefLL }, ""); |
| static_assert (bit_cast <M> (N { 0xfeedbacdeadbeef8ULL, 0x123456789abcde42ULL }) |
| == M { -8, 59, 31, -5, 234, 0xfeedbacdU, 0x123456789abcde42ULL }, ""); |
| static_assert (bit_cast <N> (M { -8, 59, 31, -5, 234, 0xfeedbacdU, 0x123456789abcde42ULL }) |
| == N { 0xfeedbacdeadbeef8ULL, 0x123456789abcde42ULL }, ""); |
| #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
| static_assert (bit_cast <J> (K { 0x0feedbacdeadbeefLL, -9103311533965288635LL, 0x0feedbacdeadbeefLL }) |
| == J { 0x0feedbacdeadbeefLL, -1011, 2, -0xbacdeadbeLL, -1, -303, 1, 0x0feedbacdeadbeefLL }, ""); |
| static_assert (bit_cast <K> (J { 0x0feedbacdeadbeefLL, -1011, 2, -0xbacdeadbeLL, -1, -303, 1, 0x0feedbacdeadbeefLL }) |
| == K { 0x0feedbacdeadbeefLL, -9103311533965288635LL, 0x0feedbacdeadbeefLL }, ""); |
| static_assert (bit_cast <M> (N { 0xfeedbacdeadbeef8ULL, 0x123456789abcde42ULL }) |
| == M { -1, -35, -19, -6, 205, 0xeadbeef8U, 0x123456789abcde42ULL }, ""); |
| static_assert (bit_cast <N> (M { -1, -35, -19, -6, 205, 0xeadbeef8U, 0x123456789abcde42ULL }) |
| == N { 0xfeedbacdeadbeef8ULL, 0x123456789abcde42ULL }, ""); |
| #endif |
| #endif |
