Question

我有以下代码：

#include <cstdint>

#pragma pack(1)
using MyType_t = union {
    uint8_t buffer[16];
    struct {
        uint64_t  a         : 55;   
        uint64_t  b         : 24;   
        uint64_t  c         : 1;    
        uint64_t  d         : 48;   
    }fields;
};
#pragma pack()

int main()
{
    return sizeof(MyType_t);
}

我在gcc \ clang和Visual C ++（Microsoft CL）之间得到了不同的结果，当我在Compiler Explorer中比较汇编代码时，我得到了以下内容：

clang（-std = c ++ 11 -O3）

main:                                   # @main
        mov     eax, 16
        ret

x86-64 gcc 6.3（-O3）

main:
        mov     eax, 16
        ret

x86-64 CL 19 2017 RTW（-Ox）

main    PROC
        mov      eax, 24
        ret      0
main    ENDP

是Visual C ++编译器错误还是未定义的行为？

Answer 1

我相信这是未定义的行为。 @NathanOliver有正确答案：GCC和Clang跨越两个uint64_t值。但是当你阅读它时需要付出代价：在Compiler Explorer上看到这个非常相似的代码示例，GCC现在必须读取两个字段并做一些数学计算以得到第二个值。

Answer 2

如果你希望两个编译器在两个编译器之间保持一致，你可以使用GCC的__attribute__((ms_struct))指令让它使用微软的位域布局算法：

using MyType_t 
= union {
    uint8_t buffer[16];
    struct  __attribute__((ms_struct)) {
        uint64_t  a         : 55;   
        uint64_t  b         : 24;   
        uint64_t  c         : 1;    
        uint64_t  d         : 48;   
    }fields;
};

你也可以在GCC中使用-mms-bitfields选项，但这是一个可能破坏其他代码的ABI更改选项。

如果你想走另一条路，并强迫微软的编译器使用GCC的位域布局，我认为没有任何属性或选项可以做到这一点。您必须更改代码并拆分b成员，使其不会跨越64位边界。类似的东西：

#pragma pack(1)
typedef union {
    uint8_t buffer[16];
#ifdef USE_GCC_BITFIELDS
    struct __attribute__((gcc_struct))  {
        uint64_t  a         : 55;   
        uint64_t  b         : 24;   
        uint64_t  c         : 1;    
        uint64_t  d         : 48;   
    }fields;
    uint64_t get_a() { return fields.a; }
    uint64_t get_b() { return fields.b; }
    uint64_t get_c() { return fields.c; }
    uint64_t get_d() { return fields.d; }
#elif defined(USE_MS_BITFIELDS)
    struct {
        uint64_t  a         : 55;   
        uint64_t  bl        : 9;
        uint64_t  bh        : 15;  
        uint64_t  c         : 1;    
        uint64_t  d         : 48;   
    }fields;
    uint64_t get_a() { return fields.a; }
    uint64_t get_b() { return fields.bl | (fields.bh << 9); }
    uint64_t get_c() { return fields.c; }
    uint64_t get_d() { return fields.d; }
#else /* portable code that should work anywhere */
    unsigned long long get_ull(int i) {
        typedef unsigned long long ull; unsigned char *p = buffer + i;
        return (ull) p[0] | ((ull) p[1] << 8) | ((ull) p[2] << 16) | ((ull) p[3] <<  24)
            | ((ull) p[4] << 32) | ((ull) p[5] << 40) | (((ull) p[6]) << 48)
            | ((ull) p[7] << 56); }
    unsigned long long get_a() { return get_ull(0) & ((1ULL << 55) - 1); }
    unsigned get_b() { return (buffer[6] >> 7) | (buffer[7] << 1) 
            | (buffer[8] << 9) | ((buffer[9] & 0x7F) << 17); }
    unsigned get_c() { return buffer[9] >> 7; }
    unsigned long long get_d() { return get_ull(8) >> 16; }
#endif

} MyType_t;
#pragma pack()

gcc和MSFT CL之间的Bitfield结构大小不同

2 个答案: