gcc和MSFT CL之間的位域結構大小不同

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);
}

當我在Compiler Explorer中比較匯編代碼並得到以下信息時，我在gcc \\ clang和Visual C ++（Microsoft CL）之間得到了不同的結果：

鐺（-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))指令，使其使用Microsoft的位域布局算法：

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更改選項，可能會破壞其他代碼。

如果您想采用另一種方法，並迫使Microsoft的編譯器使用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()