Apa cara yang benar untuk mengonversi 2 byte ke integer 16-bit yang sudah ditandatangani?

Dalam jawaban ini , zwol membuat klaim ini:

Cara yang benar untuk mengkonversi dua byte data dari sumber eksternal menjadi integer bertanda 16-bit adalah dengan fungsi pembantu seperti ini:

#include <stdint.h>

int16_t be16_to_cpu_signed(const uint8_t data[static 2]) {
    uint32_t val = (((uint32_t)data[0]) << 8) | 
                   (((uint32_t)data[1]) << 0);
    return ((int32_t) val) - 0x10000u;
}

int16_t le16_to_cpu_signed(const uint8_t data[static 2]) {
    uint32_t val = (((uint32_t)data[0]) << 0) | 
                   (((uint32_t)data[1]) << 8);
    return ((int32_t) val) - 0x10000u;
}

Manakah dari fungsi di atas yang sesuai tergantung pada apakah array berisi representasi endian kecil atau besar. Endianness bukan masalah yang dipertanyakan di sini, saya bertanya-tanya mengapa zwol mengurangi 0x10000udari uint32_tnilai yang dikonversi int32_t.

Mengapa ini cara yang benar ?

Bagaimana cara menghindari perilaku yang ditentukan implementasi ketika mengkonversi ke tipe kembali?

Karena Anda dapat mengasumsikan representasi komplemen 2's, bagaimana gips sederhana ini gagal: return (uint16_t)val;

Apa yang salah dengan solusi naif ini:

int16_t le16_to_cpu_signed(const uint8_t data[static 2]) {
    return (uint16_t)data[0] | ((uint16_t)data[1] << 8);
}

Jika int16-bit maka versi Anda bergantung pada perilaku yang ditentukan implementasi jika nilai ekspresi dalam returnpernyataan di luar kisaran int16_t.

Namun versi pertama juga memiliki masalah serupa; misalnya jika int32_tadalah typedef untuk int, dan byte input keduanya 0xFF, maka hasil pengurangan dalam pernyataan kembali adalah UINT_MAXyang menyebabkan perilaku yang ditentukan implementasi ketika dikonversi ke int16_t.

IMHO jawaban yang Anda tautkan memiliki beberapa masalah besar.

Ini harus benar pedantically dan bekerja juga pada platform yang menggunakan bit tanda atau representasi komplemen 1 , alih-alih pelengkap 2 yang biasa . Input byte dianggap sebagai komplemen 2's.

int le16_to_cpu_signed(const uint8_t data[static 2]) {
    unsigned value = data[0] | ((unsigned)data[1] << 8);
    if (value & 0x8000)
        return -(int)(~value) - 1;
    else
        return value;
}

Karena cabang, itu akan lebih mahal daripada opsi lain.

Apa yang dicapai ini adalah bahwa ia menghindari asumsi tentang bagaimana intketerwakilan berhubunganunsigned representasi pada platform. Para pemain intdiharuskan untuk mempertahankan nilai aritmatika untuk nomor apa pun yang sesuai dengan tipe target. Karena inversi memastikan bit top dari angka 16-bit akan menjadi nol, nilainya akan pas. Kemudian unary -dan pengurangan 1 menerapkan aturan biasa untuk negasi komplemen 2's. Tergantung pada platform, INT16_MINmasih bisa meluap jika tidak sesuai dengan inttipe pada target, dalam hal ini longharus digunakan.

Perbedaan ke versi asli dalam pertanyaan muncul di waktu pengembalian. Sementara yang asli selalu dikurangkan 0x10000dan komplemen 2's membiarkan overflow yang ditandatangani membungkusnya ke int16_tkisaran, versi ini memiliki eksplisit ifyang menghindari wrapover yang ditandatangani (yang tidak ditentukan ).

Sekarang dalam praktiknya, hampir semua platform yang digunakan saat ini menggunakan representasi komplemen 2's. Bahkan, jika platform memiliki standar-standar stdint.hyang mendefinisikan int32_t, itu harus menggunakan komplemen 2 untuk itu. Di mana pendekatan ini kadang-kadang berguna adalah dengan beberapa bahasa skrip yang tidak memiliki tipe data integer sama sekali - Anda dapat memodifikasi operasi yang ditunjukkan di atas untuk float dan itu akan memberikan hasil yang benar.

Metode lain - menggunakan union:

union B2I16
{
   int16_t i;
   byte    b[2];
};

Dalam program:

...
B2I16 conv;

conv.b[0] = first_byte;
conv.b[1] = second_byte;
int16_t result = conv.i;

first_bytedan second_bytedapat ditukar sesuai dengan model endian kecil atau besar. Metode ini tidak lebih baik tetapi merupakan salah satu alternatif.

Operator aritmatika bergeser dan bitwise-atau dalam ekspresi (uint16_t)data[0] | ((uint16_t)data[1] << 8)tidak bekerja pada tipe yang lebih kecil dari int, sehingga uint16_tnilai - nilai tersebut dipromosikan ke int(atau unsignedjikasizeof(uint16_t) == sizeof(int) ). Meski begitu, itu harus menghasilkan jawaban yang benar, karena hanya 2 byte yang lebih rendah yang mengandung nilai.

Versi pedantically lain yang benar untuk konversi big-endian ke little-endian (dengan asumsi little-endian CPU) adalah:

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

int16_t be16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
    memcpy(&r, data, sizeof r);
    return __builtin_bswap16(r);
}

memcpydigunakan untuk menyalin representasi int16_tdan itu adalah cara yang sesuai standar untuk melakukannya. Versi ini juga mengkompilasi menjadi 1 instruksi movbe, lihat perakitan .

Berikut adalah versi lain yang hanya bergantung pada perilaku portabel dan terdefinisi dengan baik (header #include <endian.h>bukan standar, kodenya):

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

static inline void swap(uint8_t* a, uint8_t* b) {
    uint8_t t = *a;
    *a = *b;
    *b = t;
}
static inline void reverse(uint8_t* data, int data_len) {
    for(int i = 0, j = data_len / 2; i < j; ++i)
        swap(data + i, data + data_len - 1 - i);
}

int16_t be16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
#if __BYTE_ORDER == __LITTLE_ENDIAN
    uint8_t data2[sizeof r];
    memcpy(data2, data, sizeof data2);
    reverse(data2, sizeof data2);
    memcpy(&r, data2, sizeof r);
#else
    memcpy(&r, data, sizeof r);
#endif
    return r;
}

Versi little-endian mengkompilasi ke movbeinstruksi tunggal dengan clang, gccversi kurang optimal, lihat perakitan .

Saya ingin mengucapkan terima kasih kepada semua kontributor atas jawaban mereka. Inilah yang menjadi tujuan kerja kolektif:

1. Sesuai dengan Standar C 7.20.1.1 Tipe integer lebar-lebar : tipe uint8_t, int16_tdan uint16_tharus menggunakan representasi komplemen dua tanpa bit padding, sehingga bit sebenarnya dari representasi secara jelas dari 2 byte dalam array, dalam urutan yang ditentukan oleh nama fungsi.
2. menghitung nilai 16 bit yang tidak ditandatangani dengan (unsigned)data[0] | ((unsigned)data[1] << 8) (untuk versi endian kecil) mengkompilasi ke instruksi tunggal dan menghasilkan nilai 16-bit yang tidak ditandatangani.
3. Sesuai dengan Standar C 6.3.1.3 Bilangan bulat yang ditandatangani dan tidak ditandatangani : mengonversi nilai tipe uint16_tke tipe yang ditandatangani int16_tmemiliki perilaku implementasi yang ditetapkan jika nilainya tidak dalam kisaran tipe tujuan. Tidak ada ketentuan khusus yang dibuat untuk jenis yang perwakilannya didefinisikan secara tepat.
4. untuk menghindari implementasi perilaku yang didefinisikan ini, seseorang dapat menguji apakah nilai yang tidak ditandatangani lebih besar dari INT_MAXdan menghitung nilai yang ditandatangani dengan mengurangi 0x10000. Melakukan ini untuk semua nilai seperti yang disarankan oleh zwol dapat menghasilkan nilai di luar rentang int16_tdengan perilaku yang didefinisikan implementasi yang sama.
5. menguji 0x8000bit secara eksplisit menyebabkan kompiler menghasilkan kode yang tidak efisien.
6. konversi yang lebih efisien tanpa implementasi perilaku yang didefinisikan menggunakan jenis hukuman melalui serikat pekerja, tetapi perdebatan mengenai definisi pendekatan ini masih terbuka, bahkan di tingkat Komite Standar C.
7. type punning dapat dilakukan dengan mudah dan dengan perilaku yang jelas menggunakan memcpy.

Menggabungkan poin 2 dan 7, berikut ini adalah solusi portabel dan terdefinisi penuh yang mengkompilasi secara efisien ke satu instruksi dengan gcc dan dentang :

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

int16_t be16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
    uint16_t u = (unsigned)data[1] | ((unsigned)data[0] << 8);
    memcpy(&r, &u, sizeof r);
    return r;
}

int16_t le16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
    uint16_t u = (unsigned)data[0] | ((unsigned)data[1] << 8);
    memcpy(&r, &u, sizeof r);
    return r;
}

Perakitan 64-bit :

be16_to_cpu_signed(unsigned char const*):
        movbe   ax, WORD PTR [rdi]
        ret
le16_to_cpu_signed(unsigned char const*):
        movzx   eax, WORD PTR [rdi]
        ret