在Clang中将uint64_t转换为字节数组并进行最佳移植 [英] Convert uint64_t to byte array portably and optimally in Clang

问题描述

如果要将 uint64_t 转换为 uint8_t [8] （小尾数）。在小端字节体系结构上，您只能执行难看的 reinterpret_cast<> 或 memcpy（），例如：

If you want to convert uint64_t to a uint8_t[8] (little endian). On a little endian architecture you can just do an ugly reinterpret_cast<> or memcpy(), e.g:

void from_memcpy(const std::uint64_t &x, uint8_t* bytes) {
    std::memcpy(bytes, &x, sizeof(x));
}

这会产生有效的汇编：

mov     rax, qword ptr [rdi]
mov     qword ptr [rsi], rax
ret

但是它不是便携式的。

However it is not portable. It will have different behaviour on a little endian machine.

用于将 uint8_t [8] 转换为 uint64_t 有一个很好的解决方案-只需执行以下操作即可：

For converting uint8_t[8] to uint64_t there is a great solution - just do this:

void to(const std::uint8_t* bytes, std::uint64_t &x) {
    x = (std::uint64_t(bytes[0]) << 8*0) |
        (std::uint64_t(bytes[1]) << 8*1) |
        (std::uint64_t(bytes[2]) << 8*2) |
        (std::uint64_t(bytes[3]) << 8*3) |
        (std::uint64_t(bytes[4]) << 8*4) |
        (std::uint64_t(bytes[5]) << 8*5) |
        (std::uint64_t(bytes[6]) << 8*6) |
        (std::uint64_t(bytes[7]) << 8*7);
}

这看起来效率低下，但实际上使用Clang -O2 会生成与以前完全相同的程序集，如果在大型字节序计算机上进行编译，它将足够聪明以使用本机字节交换指令。例如。这段代码：

This looks inefficient but actually with Clang -O2 it generates exactly the same assembly as before, and if you compile on a big endian machine it will be smart enough to use a native byte swap instruction. E.g. this code:

void to(const std::uint8_t* bytes, std::uint64_t &x) {
    x = (std::uint64_t(bytes[7]) << 8*0) |
        (std::uint64_t(bytes[6]) << 8*1) |
        (std::uint64_t(bytes[5]) << 8*2) |
        (std::uint64_t(bytes[4]) << 8*3) |
        (std::uint64_t(bytes[3]) << 8*4) |
        (std::uint64_t(bytes[2]) << 8*5) |
        (std::uint64_t(bytes[1]) << 8*6) |
        (std::uint64_t(bytes[0]) << 8*7);
}

编译为：

mov     rax, qword ptr [rdi]
bswap   rax
mov     qword ptr [rsi], rax
ret

我的问题是：是否存在等效的可靠优化的构造，可用于反向转换？我已经尝试过了，但是天真地编译了它：

My question is: is there an equivalent reliably-optimised construct for converting in the opposite direction? I've tried this, but it gets compiled naively:

void from(const std::uint64_t &x, uint8_t* bytes) {
    bytes[0] = x >> 8*0;
    bytes[1] = x >> 8*1;
    bytes[2] = x >> 8*2;
    bytes[3] = x >> 8*3;
    bytes[4] = x >> 8*4;
    bytes[5] = x >> 8*5;
    bytes[6] = x >> 8*6;
    bytes[7] = x >> 8*7;
}

编辑：经过一些试验，此代码可以只要使用 uint8_t * __restrict__个字节，就可以在GCC 8.1和更高版本中进行最佳编译。但是我仍然没有找到Clang可以优化的形式。

After some experimentation, this code does get compiled optimally with GCC 8.1 and later as long as you use uint8_t* __restrict__ bytes. However I still haven't managed to find a form that Clang will optimise.

推荐答案

返回值如何？
易于推理和小型汇编：

What about returning a value? Easy to reason about and small assembly:

#include <cstdint>
#include <array>

auto to_bytes(std::uint64_t x)
{
    std::array<std::uint8_t, 8> b;
    b[0] = x >> 8*0;
    b[1] = x >> 8*1;
    b[2] = x >> 8*2;
    b[3] = x >> 8*3;
    b[4] = x >> 8*4;
    b[5] = x >> 8*5;
    b[6] = x >> 8*6;
    b[7] = x >> 8*7;
    return b;
}

https://godbolt.org/z/FCroX5

和大字节序：

#include <stdint.h>

struct mybytearray
{
    uint8_t bytes[8];
};

auto to_bytes(uint64_t x)
{
    mybytearray b;
    b.bytes[0] = x >> 8*0;
    b.bytes[1] = x >> 8*1;
    b.bytes[2] = x >> 8*2;
    b.bytes[3] = x >> 8*3;
    b.bytes[4] = x >> 8*4;
    b.bytes[5] = x >> 8*5;
    b.bytes[6] = x >> 8*6;
    b.bytes[7] = x >> 8*7;
    return b;
}

https://godbolt.org/z/WARCqN

（std :: array无法用于-target aarch64_be吗？ ）

(std::array not available for -target aarch64_be? )

这篇关于在Clang中将uint64_t转换为字节数组并进行最佳移植的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！