Was ist der richtige Weg, um 2 Bytes in eine vorzeichenbehaftete 16-Bit-Ganzzahl umzuwandeln?

In dieser Antwort machte zol diese Behauptung geltend:

Der richtige Weg, zwei Datenbytes aus einer externen Quelle in eine 16-Bit-Ganzzahl mit Vorzeichen umzuwandeln, sind Hilfsfunktionen wie diese:

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

Welche der obigen Funktionen geeignet ist, hängt davon ab, ob das Array eine Little-Endian- oder eine Big-Endian-Darstellung enthält. Endianness ist hier nicht das Thema, ich frage mich warum zwöl subtrahiert 0x10000u von dem uint32_t Wert umgewandelt in int32_t.

Warum ist das der richtige Weg?

Wie vermeidet es das durch die Implementierung definierte Verhalten beim Konvertieren in den Rückgabetyp?

Da Sie die Komplementdarstellung von 2 annehmen können, wie würde diese einfachere Umwandlung fehlschlagen: return (uint16_t)val;

Was ist falsch an dieser naiven Lösung:

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

Wenn int 16-Bit ist, dann verlässt sich Ihre Version auf implementierungsdefiniertes Verhalten, wenn der Wert des Ausdrucks in der return Anweisung liegt außerhalb des gültigen Bereichs für int16_t.

Die erste Version hat jedoch auch ein ähnliches Problem; zum Beispiel wenn int32_t ist ein Typdef für intund die Eingabebytes sind beides 0xFFdann ist das Ergebnis der Subtraktion in der return-Anweisung UINT_MAX was bei der Konvertierung zu implementierungsdefiniertem Verhalten führt int16_t.

IMHO hat die Antwort, auf die Sie verlinken, mehrere Hauptprobleme.

Dies sollte umständlich korrekt sein und auch auf Plattformen funktionieren, die dies verwenden Zeichenbit oder 1er-Komplement Darstellungen statt der üblichen 2er Komplement. Es wird davon ausgegangen, dass die Eingangsbytes im Zweierkomplement vorliegen.

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

Aufgrund der Verzweigung wird es teurer als andere Optionen.

Was dies erreicht, ist, dass es jede Annahme darüber vermeidet, wie int Vertretung betrifft unsigned Vertretung auf der Plattform. Die Besetzung zu int ist erforderlich, um den arithmetischen Wert für jede Zahl beizubehalten, die in den Zieltyp passt. Da die Umkehrung sicherstellt, dass das oberste Bit einer 16-Bit-Zahl Null ist, passt der Wert. Dann das Unäre - und Subtraktion von 1 wenden die übliche Regel für die 2er-Komplement-Negation an. Je nach Plattform, INT16_MIN könnte immer noch überlaufen, wenn es nicht in die passt int tippen Sie auf das Ziel, in diesem Fall long sollte benutzt werden.

Der Unterschied zur Originalversion in Frage kommt bei der Rückgabezeit. Während das Original eben immer abgezogen wird 0x10000 und das 2er-Komplement lassen Sie den vorzeichenbehafteten Überlauf umwickeln int16_t Bereich hat diese Version die explizite if das vermeidet einen signierten Wrapover (der nicht definiert ist).

In der Praxis verwenden fast alle heute verwendeten Plattformen die 2er-Komplementdarstellung. In der Tat, wenn die Plattform standardkonform ist stdint.h das definiert int32_tes muss Verwenden Sie dafür das 2er-Komplement. Wo dieser Ansatz manchmal praktisch ist, sind einige Skriptsprachen, die überhaupt keine Integer-Datentypen haben – Sie können die oben gezeigten Operationen für Gleitkommazahlen ändern und es wird das richtige Ergebnis liefern.

Eine andere Methode – mit union:

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

Im Programm:

...
B2I16 conv;

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

first_byte und second_byte kann nach Little- oder Big-Endian-Modell ausgetauscht werden. Diese Methode ist nicht besser, aber eine der Alternativen.

Die arithmetischen Operatoren Wechsel und bitweise-oder im Ausdruck (uint16_t)data[0] | ((uint16_t)data[1] << 8) Arbeiten Sie nicht an Typen, die kleiner als sind intdamit diese uint16_t Werte werden gefördert int (oder unsigned wenn sizeof(uint16_t) == sizeof(int)). Trotzdem sollte das die richtige Antwort liefern, da nur die unteren 2 Bytes den Wert enthalten.

Eine andere pedantisch korrekte Version für die Konvertierung von Big-Endian nach Little-Endian (unter der Annahme einer Little-Endian-CPU) ist:

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

memcpy wird verwendet, um die Darstellung von zu kopieren int16_t und das ist der normkonforme Weg. Diese Version kompiliert auch in 1 Anweisung movbesehen Montage.

Hier ist eine andere Version, die nur auf portable und wohldefinierte Verhaltensweisen (header #include <endian.h> ist nicht Standard, der Code lautet):

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

Die Little-Endian-Version wird zu Single kompiliert movbe Anleitung mit clang, gcc Version ist weniger optimal, siehe Montage.

Ich möchte allen Mitwirkenden für ihre Antworten danken. Darauf läuft das Kollektivwerk hinaus:

1. Nach C-Norm 7.20.1.1 Integer-Typen mit exakter Breite: Typen uint8_t, int16_t und uint16_t muss die Zweierkomplementdarstellung ohne Füllbits verwenden, sodass die tatsächlichen Bits der Darstellung eindeutig die der 2 Bytes im Array sind, in der Reihenfolge, die durch die Funktionsnamen angegeben ist.
2. Berechnung des vorzeichenlosen 16-Bit-Werts mit (unsigned)data[0] | ((unsigned)data[1] << 8) (für die Little-Endian-Version) wird zu einer einzelnen Anweisung kompiliert und ergibt einen vorzeichenlosen 16-Bit-Wert.
3. Nach C-Norm 6.3.1.3 Ganzzahlen mit und ohne Vorzeichen: Konvertieren eines Werts vom Typ uint16_t auf signierten Typ int16_t weist implementierungsdefiniertes Verhalten auf, wenn der Wert nicht im Bereich des Zieltyps liegt. Für Typen, deren Repräsentation genau definiert ist, sind keine besonderen Vorkehrungen getroffen.
4. Um dieses implementierungsdefinierte Verhalten zu vermeiden, kann man testen, ob der vorzeichenlose Wert größer als ist INT_MAX und den entsprechenden vorzeichenbehafteten Wert durch Subtrahieren berechnen 0x10000. Tun Sie dies für alle Werte, wie von vorgeschlagen zwöl kann Werte außerhalb des Bereichs von erzeugen int16_t mit dem gleichen implementierungsdefinierten Verhalten.
5. Prüfung für die 0x8000 bit bewirkt explizit, dass die Compiler ineffizienten Code erzeugen.
6. eine effizientere Konvertierung ohne Implementierung definierter Verhaltensweisen tippe wortspiel über eine Gewerkschaft, aber die Debatte über die Definiertheit dieses Ansatzes ist noch offen, sogar auf der Ebene des C-Standard-Ausschusses.
7. tippe wortspiel kann portabel und mit definiertem Verhalten ausgeführt werden memcpy.

Durch die Kombination der Punkte 2 und 7 ist hier eine portable und vollständig definierte Lösung, die mit beiden effizient zu einer einzigen Anweisung kompiliert werden kann gcc und klirren:

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

64-Bit-Assembly:

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

Warum nicht einfach Ihre “naive Lösung” verwenden, sondern jedes Element umwandeln int16_t Anstatt von uint16_t?

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

Dann müssten Sie sich nicht damit befassen, unsigned ints in signed ints umzuwandeln (und möglicherweise außerhalb des signed int-Bereichs zu sein).