MSVC无法生成二进制流读取高效汇编，求端序无关高效实现方案

需求目标 #

需要实现满足以下特性的32位类型二进制流读取代码：

• 不依赖主机端序，源数据端序为已知固定值
• 尽量符合C17标准，可接受广泛认可的实现定义行为；无类型双关操作，不违反严格别名规则与指针对齐规则
• 现代编译器需生成高效指令，性能接近直接内存加载（mov）或加载+字节交换（mov+bswap）
• 整数类型采用补码表示
• 浮点数符合IEEE 754标准，端序处理规则与整数一致
• 可忽略混合端序、运行时端序可变的特殊平台

现有实现与效率问题 #

整数读取实现 #

当前的整数读取代码通过位操作直接构造目标值，基本符合需求（仅uint32_t赋值给int32_t属于可接受的实现定义行为）：

#include <stdint.h>

int32_t read_i32_from_le(uint8_t* data)
{
    int32_t r = ((uint32_t)data[0] << 0) | 
                ((uint32_t)data[1] << 8) | 
                ((uint32_t)data[2] << 16) | 
                ((uint32_t)data[3] << 24);
    return r;
}

uint32_t read_u32_from_le(uint8_t* data)
{
    uint32_t r = ((uint32_t)data[0] << 0) |
                 ((uint32_t)data[1] << 8) | 
                 ((uint32_t)data[2] << 16) | 
                 ((uint32_t)data[3] << 24);
    return r;
}

int32_t read_i32_from_be(uint8_t* data)
{
    int32_t r = ((uint32_t)data[3] << 0) | 
                ((uint32_t)data[2] << 8) | 
                ((uint32_t)data[1] << 16) | 
                ((uint32_t)data[0] << 24);
    return r;
}

uint32_t read_u32_from_be(uint8_t* data)
{
    uint32_t r = ((uint32_t)data[3] << 0) |
                 ((uint32_t)data[2] << 8) | 
                 ((uint32_t)data[1] << 16) | 
                 ((uint32_t)data[0] << 24);
    return r;
}

但该代码在MSVC下生成的汇编指令效率低下，以read_i32_from_le为例：

read_i32_from_le PROC                             ; COMDAT
        movzx   edx, BYTE PTR [rcx+2]
        movzx   eax, BYTE PTR [rcx+3]
        shl     eax, 8
        or      eax, edx
        movzx   edx, BYTE PTR [rcx+1]
        movzx   ecx, BYTE PTR [rcx]
        shl     eax, 8
        or      eax, edx
        shl     eax, 8
        or      eax, ecx
        ret     0

浮点数读取实现 #

浮点数读取复用整数读取函数，通过memcpy完成位模式转换：

#include <string.h>

float read_f32_from_le(uint8_t* data)
{
    uint32_t bits = read_u32_from_le(data);
    float r;
    memcpy(&r, &bits, 4);
    return r;
}

同样，MSVC生成的指令效率不理想：

read_f32_from_le PROC                             ; COMDAT
        movzx   eax, BYTE PTR [rcx+2]
        movzx   edx, BYTE PTR [rcx+3]
        shl     edx, 8
        or      edx, eax
        movzx   eax, BYTE PTR [rcx+1]
        shl     edx, 8
        or      edx, eax
        movzx   eax, BYTE PTR [rcx]
        shl     edx, 8
        or      edx, eax
        mov     DWORD PTR r$[rsp], edx
        movss   xmm0, DWORD PTR r$[rsp]
        ret     0

问题解答 #

1. 符合要求的替代实现方式 #

有几种更高效且符合需求的实现方案：

方案1：基于memcpy+编译时端序判断

利用编译时常量判断主机端序，结合字节交换内置函数，编译器会自动优化掉分支，生成高效指令：

#include <stdint.h>
#include <string.h>

// 编译时判断主机端序，无运行时开销
static const uint32_t _endian_test = 1;
#define IS_LITTLE_ENDIAN (*(const uint8_t*)&_endian_test == 1)

// 跨编译器字节交换内置函数封装
#if defined(__GNUC__) || defined(__clang__)
#define bswap32(x) __builtin_bswap32(x)
#elif defined(_MSC_VER)
#define bswap32(x) _byteswap_ulong(x)
#endif

uint32_t read_u32_from_le(uint8_t* data) {
    uint32_t val;
    memcpy(&val, data, sizeof(val));
    // 仅当主机是大端时才交换字节，编译器会优化为常量分支
    if (!IS_LITTLE_ENDIAN) {
        val = bswap32(val);
    }
    return val;
}

uint32_t read_u32_from_be(uint8_t* data) {
    uint32_t val;
    memcpy(&val, data, sizeof(val));
    if (IS_LITTLE_ENDIAN) {
        val = bswap32(val);
    }
    return val;
}

int32_t read_i32_from_le(uint8_t* data) {
    return (int32_t)read_u32_from_le(data);
}

int32_t read_i32_from_be(uint8_t* data) {
    return (int32_t)read_u32_from_be(data);
}

方案2：联合类型实现浮点数转换

使用联合类型完成整数到浮点数的位模式转换，避免memcpy的额外开销，且符合C标准（联合是严格别名规则的例外）：

float read_f32_from_le(uint8_t* data) {
    union {
        uint32_t u_val;
        float f_val;
    } conv;
    conv.u_val = read_u32_from_le(data);
    return conv.f_val;
}

float read_f32_from_be(uint8_t* data) {
    union {
        uint32_t u_val;
        float f_val;
    } conv;
    conv.u_val = read_u32_from_be(data);
    return conv.f_val;
}

这些方案既不依赖主机端序的条件编译，也不违反标准规则，同时现代编译器（包括MSVC）能生成接近最优的指令（直接加载或加载+字节交换）。

2. 是否属于MSVC编译器Bug？是否需要提交反馈？ #

这不属于编译器Bug，而是MSVC优化器的模式匹配能力不足：GCC、Clang等编译器能识别原始位操作代码的意图，自动将其优化为高效的加载+字节交换指令，但MSVC目前无法识别这类模式。

你可以向微软提交反馈，描述该场景下的优化缺失，帮助他们提升编译器的优化能力。这类反馈有助于完善编译器对常见位操作模式的识别，提升代码生成效率。

内容的提问来源于stack exchange，提问作者Pavel T.