Quelle est la bonne façon de convertir 2 octets en un entier signé 16 bits?

Dans cette réponse , zwol a fait cette affirmation:

La bonne façon de convertir deux octets de données d'une source externe en un entier signé 16 bits est avec des fonctions d'assistance comme celle-ci:

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

Laquelle des fonctions ci-dessus est appropriée dépend du fait que le tableau contient un petit endian ou une grande représentation endian. L'endianité n'est pas le problème en cause ici, je me demande pourquoi zwol soustrait 0x10000ude la uint32_tvaleur convertie en int32_t.

Pourquoi est-ce la bonne façon ?

Comment évite-t-il le comportement défini par l'implémentation lors de la conversion au type de retour?

Puisque vous pouvez assumer la représentation du complément à 2, comment cette conversion plus simple échouerait-elle: return (uint16_t)val;

Quel est le problème avec cette solution naïve:

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

Si intest 16 bits, votre version s'appuie sur un comportement défini par l'implémentation si la valeur de l'expression dans l' returninstruction est hors limites pour int16_t.

Cependant, la première version a également un problème similaire; par exemple, si int32_test un typedef pour int, et que les octets d'entrée sont les deux 0xFF, le résultat de la soustraction dans l'instruction de retour est UINT_MAXce qui provoque le comportement défini par l'implémentation lors de la conversion en int16_t.

À mon humble avis, la réponse à laquelle vous liez a plusieurs problèmes majeurs.

Cela devrait être correct sur le plan pédiatrique et fonctionner également sur les plates-formes qui utilisent le bit de signe ou les représentations du complément à 1 , au lieu du complément à 2 habituel . Les octets d'entrée sont supposés être en complément de 2.

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

En raison de la succursale, ce sera plus cher que les autres options.

Cela permet d'éviter toute hypothèse sur la intrelation entre la unsignedreprésentation et la représentation sur la plate-forme. Le transtypage en intest requis pour conserver la valeur arithmétique de tout nombre pouvant tenir dans le type cible. Étant donné que l'inversion garantit que le bit supérieur du nombre 16 bits sera nul, la valeur s'adaptera. Ensuite, l'unaire -et la soustraction de 1 appliquent la règle habituelle pour la négation du complément à 2. Selon la plate-forme, elle INT16_MINpourrait toujours déborder si elle ne correspond pas au inttype sur la cible, auquel cas elle longdoit être utilisée.

La différence avec la version originale dans la question vient au moment du retour. Alors que l'original est toujours soustrait 0x10000et que le complément à 2 laisse le débordement signé l'envelopper int16_t, il est explicite ifqui évite le wrapover signé (qui n'est pas défini ).

Maintenant, dans la pratique, presque toutes les plateformes utilisées aujourd'hui utilisent la représentation du complément à 2. En fait, si la plate-forme est conforme aux normes stdint.hqui la définit int32_t, elle doit utiliser le complément 2 pour cela. Lorsque cette approche est parfois utile, c'est avec certains langages de script qui n'ont pas du tout de types de données entiers - vous pouvez modifier les opérations indiquées ci-dessus pour les flottants et cela donnera le résultat correct.

Une autre méthode - en utilisant union:

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

Au programme:

...
B2I16 conv;

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

first_byteet second_bytepeuvent être échangés selon le modèle petit ou grand endien. Cette méthode n'est pas meilleure mais est l'une des alternatives.

Les opérateurs arithmétiques shift et expression au niveau du bit ou in (uint16_t)data[0] | ((uint16_t)data[1] << 8)ne fonctionnent pas sur les types plus petits que int, de sorte que ces uint16_tvaleurs soient promues en int(ou unsignedsi sizeof(uint16_t) == sizeof(int)). Cependant, cela devrait donner la bonne réponse, car seuls les 2 octets inférieurs contiennent la valeur.

Une autre version pédantiquement correcte pour la conversion big-endian en little-endian (en supposant que le processeur little-endian) est:

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

memcpyest utilisé pour copier la représentation de int16_tet c'est la manière conforme aux normes de le faire. Cette version se compile également en 1 instruction movbe, voir assemblage .

Voici une autre version qui ne repose que sur des comportements portables et bien définis (l'en-tête #include <endian.h>n'est pas standard, le code l'est):

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

La version little-endian se compile en movbeinstruction unique avec clang, la gccversion est moins optimale, voir assemblage .

Je tiens à remercier tous les contributeurs pour leurs réponses. Voici ce que le travail collectif se résume à:

1. Conformément à la norme C 7.20.1.1 Types entiers de largeur exacte : types uint8_t, int16_tet uint16_tdoivent utiliser la représentation du complément à deux sans aucun bit de remplissage, de sorte que les bits réels de la représentation sont sans ambiguïté ceux des 2 octets du tableau, dans l'ordre spécifié par les noms des fonctions.
2. le calcul de la valeur 16 bits non signée avec (unsigned)data[0] | ((unsigned)data[1] << 8)(pour la petite version endienne) se compile en une seule instruction et produit une valeur 16 bits non signée.
3. Conformément à la norme C 6.3.1.3 Entiers signés et non signés : la conversion d'une valeur de type uint16_ten type signé int16_ta un comportement défini par l'implémentation si la valeur n'est pas dans la plage du type de destination. Aucune disposition particulière n'est prévue pour les types dont la représentation est définie avec précision.
4. pour éviter ce comportement défini par l'implémentation, on peut tester si la valeur non signée est supérieure à INT_MAXet calculer la valeur signée correspondante en soustrayant 0x10000. Faire cela pour toutes les valeurs comme suggéré par zwol peut produire des valeurs en dehors de la plage de int16_tavec le même comportement défini par l'implémentation.
5. le test du 0x8000bit entraîne explicitement les compilateurs à produire du code inefficace.
6. une conversion plus efficace sans implémentation du comportement défini utilise le type punning via un syndicat, mais le débat concernant la définition de cette approche est toujours ouvert, même au niveau du comité de la norme C.
7. la punition de type peut être effectuée de manière portative et avec un comportement défini à l'aide de memcpy.

En combinant les points 2 et 7, voici une solution portable et entièrement définie qui se compile efficacement en une seule instruction avec gcc et clang :

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

Assemblage 64 bits :

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