Bit-casting object representations (p0476r2)

[zoecarver]

Summary

Add bit_cast function outlined here.

[zoecarver]

include/bit

168

It would be great if this could use the llvm BitCastInst but I am not sure how to add support for this in the compiler. Maybe you know @mclow.lists?

[zoecarver]

Update version, status, and ensure that libcxx std version is over 17.

[jfb]

You need support from the compiler for constexpr support. I don't think we want this without constexpr. @erik.pilkington was looking into this.

[zoecarver]

I talked with @lebedev.ri a bit about this on the IRC channel. @jfb do you know if the bitcast instruction would work for constexpr without type punning? It seems like memcpy (and __builtin_memcpy ) is not the way to go.

[zoecarver]

Here is another idea, what if we treated fundamental types differently because they can be cast using c-style casting? Like this:

    std::is_fundamental<_To>::value &&
    std::is_fundamental<_Fm>::value,
    _To
>::type
bit_cast(const _Fm &__src) noexcept
{
    return (_To) __src;
}

[jfb]

In D58004#1391846, @zoecarver wrote:

Here is another idea, what if we treated fundamental types differently because they can be cast using c-style casting? Like this:

    std::is_fundamental<_To>::value &&
    std::is_fundamental<_Fm>::value,
    _To
>::type
bit_cast(const _Fm &__src) noexcept
{
    return (_To) __src;
}

I don't think you'll need any of this once we have a builtin.

[zoecarver]

For sure, but would it work instead of a builtin?

Is there some documentation on adding builtins to clang? I am happy to work on writing one I just don't know where to start.

[jfb]

In D58004#1391848, @zoecarver wrote:

For sure, but would it work instead of a builtin?

No, because it wouldn't support everything the standard says. Things like float -> int are also wrong with what you suggest.

Is there some documentation on adding builtins to clang? I am happy to work on writing one I just don't know where to start.

You can look at prior builtins that were added, that's usually the easiest route. In this case I'd wait to see what Erik had, maybe he can upload his partial patch.

[zoecarver]

No, because it wouldn't support everything the standard says. Things like float -> int are also wrong with what you suggest.

Fair enough. Out of curiosity though, what is wrong with float -> int?

You can look at prior builtins that were added, that's usually the easiest route. In this case I'd wait to see what Erik had, maybe he can upload his partial patch.

Sounds good. I will look over some code and wait for him.

[jfb]

In D58004#1391850, @zoecarver wrote:

No, because it wouldn't support everything the standard says. Things like float -> int are also wrong with what you suggest.

Fair enough. Out of curiosity though, what is wrong with float -> int?

It's not doing the same thing: https://godbolt.org/z/FREjFX

[zoecarver]

I see. It's doing something like fptosi instead of a bitcast. Thanks for the link, very helpful.

[zoecarver]

@erik.pilkington friendly ping, have you made any progress on compiler support?

A more general question: bit_cast is only available in C++20 which supports the memcpy function as a constexpr, does that resolve the issue or would there be other benefits form compiler support (no type punning, etc.)?

[erik.pilkington]

In D58004#1395763, @zoecarver wrote:

@erik.pilkington friendly ping, have you made any progress on compiler support?

I'm planning on implementing this, but haven't quite gotten around to it yet. The idea is a builtin spelt __builtin_bit_cast(T, expr), that would just IRGen to a simple memcpy. In the frontend's constant evaluator (lib/AST/ExprConstant.cpp), we need to map from an APValue of one type to an APValue of another, which can get a little hairy (especially since we want to evaluate it however the target would). If you're interested in taking a look at this I can give you a more detailed brain dump and dig up some WIP patches.

A more general question: bit_cast is only available in C++20 which supports the memcpy function as a constexpr, does that resolve the issue or would there be other benefits form compiler support (no type punning, etc.)?

constexpr memcpy doesn't do type-punning, so compiler support is still needed in general.

[zoecarver]

@erik.pilkington thanks for the explanation. I will take a look at those files and see if I can understand better what needs to be done. If it seems doable (for me) I will ask about the WIP, thanks for the offer :)

include/bit

 namespace std {
 
 } // namespace std
 
 */
 
 #include <__config>
 #include <version>
+#include <memory>
 
 #if defined(__IBMCPP__)
 #include "support/ibm/support.h"
 #endif
 #if defined(_LIBCPP_COMPILER_MSVC)
 #include <intrin.h>
 #endif
 

 
 inline _LIBCPP_INLINE_VISIBILITY int __popcount(unsigned long long __x) {
   static_assert(sizeof(unsigned long long) == 8, "");
   return __popcnt64(__x);
 }
 
 #endif // _LIBCPP_COMPILER_MSVC
 
+// bit_cast
+
+#if _LIBCPP_STD_VER > 17
+
+template <typename _To, typename _Fm>
+constexpr typename enable_if<
+    (sizeof(_To) == sizeof(_Fm)) &&
+    std::is_trivially_copyable<_To>::value &&
+    std::is_trivially_copyable<_Fm>::value,
+    _To
+>::type
+bit_cast(const _Fm &__src) noexcept
+{
+    _To __dst;
+    std::memcpy(&__dst, &__src, sizeof(_To));
+    return __dst;
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_BIT

include/version

 # define __cpp_lib_void_t                               201411L
 #endif
 
 #if _LIBCPP_STD_VER > 17
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_atomic_ref                         201806L
 # endif
 // # define __cpp_lib_bind_front                           201811L
-// # define __cpp_lib_bit_cast                             201806L
+# define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
 // # define __cpp_lib_constexpr_misc                       201811L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 // # define __cpp_lib_destroying_delete                    201806L
 # define __cpp_lib_erase_if                             201811L
 // # define __cpp_lib_generic_unordered_lookup             201811L
 // # define __cpp_lib_is_constant_evaluated                201811L
 // # define __cpp_lib_list_remove_return_type              201806L
 // # define __cpp_lib_ranges                               201811L
 // # define __cpp_lib_three_way_comparison                 201711L
 #endif
 
 #endif // _LIBCPP_VERSIONH

test/libcxx/bit/bit_cast.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <bit>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T, class F>
+void test_bitcast(F init_value)
+{
+    auto cast_value = std::bit_cast<T>(init_value);
+    
+    ASSERT_SAME_TYPE(decltype(cast_value), T); // make sure type is the same
+    assert(std::bit_cast<F>(cast_value) == init_value); // make sure data isnt lost when casting back
+    
+}
+
+struct A { int a; };
+struct B { int b; };
+
+int main(int, char**)
+{
+    constexpr double d = 1234.0; // make sure it works with constexprs
+    test_bitcast<std::uint64_t>(d);
+    
+    constexpr long long int lli = 12345;
+    test_bitcast<double>(lli);
+    
+    constexpr long int li = 4321;
+    test_bitcast<float*>(&li);
+    
+    // test structs
+    constexpr A a = A {.a=123};
+    B b = std::bit_cast<B>(a);
+    assert(b.b == 123);
+    
+    return 0;
+}

www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P0858R0">P0858R0</a></td><td>LWG</td><td>Constexpr iterator requirements</td><td>Jacksonville</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0905R1">P0905R1</a></td><td>CWG</td><td>Symmetry for spaceship</td><td>Jacksonville</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0966R1">P0966R1</a></td><td>LWG</td><td><tt>string::reserve</tt> Should Not Shrink</td><td>Jacksonville</td><td>Complete</td><td>8.0</td></tr>
 
     <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0019R8">P0019R8</a></td><td>LWG</td><td>Atomic Ref</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0458R2">P0458R2</a></td><td>LWG</td><td>Checking for Existence of an Element in Associative Containers</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0475R1">P0475R1</a></td><td>LWG</td><td>LWG 2511: guaranteed copy elision for piecewise construction</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0476R2">P0476R2</a></td><td>LWG</td><td>Bit-casting object representations</td><td>Rapperswil</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0476R2">P0476R2</a></td><td>LWG</td><td>Bit-casting object representations</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0528R3">P0528R3</a></td><td>CWG</td><td>The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0542R5">P0542R5</a></td><td>CWG</td><td>Support for contract based programming in C++</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0556R3">P0556R3</a></td><td>LWG</td><td>Integral power-of-2 operations</td><td>Rapperswil</td><td><i>In Progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0619R4">P0619R4</a></td><td>LWG</td><td>Reviewing Deprecated Facilities of C++17 for C++20</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0646R1">P0646R1</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0722R3">P0722R3</a></td><td>CWG</td><td>Efficient sized delete for variable sized classes</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0758R1">P0758R1</a></td><td>LWG</td><td>Implicit conversion traits and utility functions</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0759R1">P0759R1</a></td><td>LWG</td><td>fpos Requirements</td><td>Rapperswil</td><td></td><td></td></tr>