Endianness swap sans ah

Je suis en train d'écrire un ELFE de l'analyseur, mais j'ai un peu de mal à convertir endianness correctement. J'ai des fonctions pour déterminer le boutisme de l'analyseur et les endiannness de l'objet fichier.

Fondamentalement, il existe quatre scénarios possibles:

  1. Un big endian compilé analyseur de s'exécuter sur un big endian fichier objet
    • rien ne doit converti
  2. Un big endian compilé analyseur de s'exécuter sur un little endian fichier objet
    • l'ordre des octets besoins échangés, mais ah/l() et htons/l() sont nulles les macros sur une machine big endian, de sorte qu'ils n'inverser l'ordre des octets. C'est le problème
  3. Un little endian compilé analyseur de s'exécuter sur un big endian fichier objet
    • l'ordre des octets besoins échangé, afin de l'utiliser htons() pour inverser l'ordre des octets
  4. Un little endian compilé analyseur de s'exécuter sur un little endian fichier de l'objet.
    • rien ne doit converti

Est-il une fonction que je peux utiliser explicitement swap d'octets de commande/de changement de l'endianness, depuis ah/l() et htons/l() prennent de l'hôte endianness en compte et parfois ne pas convertir? Ou dois-je trouver/écrire mon propre permuter l'ordre des octets de la fonction?

OriginalL'auteur xdumaine | 2012-04-26

  1. 3

    Faire j'ai besoin de trouver/écrire mon propre permuter l'ordre des octets de la fonction?

    Oui, vous l'avez. Mais, pour faire simple, je vous renvoie à cette question: Comment puis-je convertir entre big-endian et little-endian en C++? qui donne une liste de compilateur spécifique de l'ordre des octets de swap de fonctions, ainsi que certaines implémentations de l'ordre des octets de swap fonctions.

    OriginalL'auteur David Heffernan

  2. 10

    Je pense qu'il vaut la peine de sensibilisation L'Ordre Des Octets Du Sophisme article ici, par Rob Pyke (l'un d'Aller de l'auteur).

    Si vous faites les choses de droit -, c'est à dire vous ne présumez pas rien au sujet de vos plates-formes d'ordre des octets -- et puis il va juste travailler. Tous vous devez vous préoccuper est de savoir si le format ELF fichiers sont dans Little Endian ou Big Endian mode.

    De l'article:

    Disons que votre flux de données a un little-endian codé entier de 32 bits. Voici comment l'extraire (en supposant que les octets non signés):

    i = (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);

    Si c'est big-endian, voici comment l'extraire:

    i = (data[3]<<0) | (data[2]<<8) | (data[1]<<16) | (data[0]<<24);

    Et de laisser le compilateur s'inquiéter au sujet de l'optimisation le diable hors de lui.

    Autant que je sache, les compilateurs ne utiliser de manière optimale l'ordre des octets de swap si vous commencez avec un mot dans la première place.
    Très probablement, mais comme d'habitude, mesurer deux fois, d'optimiser la fois.

    OriginalL'auteur Matthieu M.

  3. 7

    Dans Linux il existe plusieurs fonctions de conversion dans endian.h, qui permet de convertir entre arbitraire endianness:

    uint16_t htobe16(uint16_t host_16bits);
uint16_t htole16(uint16_t host_16bits);
uint16_t be16toh(uint16_t big_endian_16bits);
uint16_t le16toh(uint16_t little_endian_16bits);

uint32_t htobe32(uint32_t host_32bits);
uint32_t htole32(uint32_t host_32bits);
uint32_t be32toh(uint32_t big_endian_32bits);
uint32_t le32toh(uint32_t little_endian_32bits);

uint64_t htobe64(uint64_t host_64bits);
uint64_t htole64(uint64_t host_64bits);
uint64_t be64toh(uint64_t big_endian_64bits);
uint64_t le64toh(uint64_t little_endian_64bits);

    Édité, moins de solution fiable. Vous pouvez utiliser de l'union pour accéder aux octets dans n'importe quel ordre. C'est assez pratique:

    union {
    short number;
    char bytes[sizeof(number)];
};
    Techniquement comportement indéfini en C++.
    Mais comment savons-nous le bon de commande?
    OP sait, quand il le veut swap d'octets. J'ai édité ma réponse à exposer le plus la bonne solution.
    C'est vraiment utile, mais malheureusement (de ma faute pour ne pas dire), mon programme doit travailler sur *nix machines qui n'ont pas cette (lire: solaris). Upvote pour le plus simple, mais j'ai accepté l'autre, comme il est plus portable.

    OriginalL'auteur Rafał Rawicki

  4. 1

    Le ah fonctions permettent de permuter entre la plus grande et little-endian. Certains systèmes sont aussi "moyen-endian" où les octets sont brouillés, plutôt que de juste commandé une manière ou d'une autre.

    De toute façon, si tout ce qui vous intéresse sont de grande taille et en little endian, puis tout ce que vous devez savoir, c'est si l'hôte et le fichier de l'objet de l'endianess diffèrent. Vous aurez votre propre fonction qui inconditionnelle des swaps d'ordre des octets et que vous aurez l'appellent ou non en fonction de si oui ou non host_endianess()==objectfile_endianess().

    OriginalL'auteur bames53

  5. 0

    Si je pense à une solution multi-plateforme qui fonctionne sur windows ou linux, je voudrais écrire quelque chose comme:

    #include <algorithm>

//dataSize is the number of bytes to convert.
char le[dataSize];//little-endian
char be[dataSize];//big-endian

//Fill contents in le here...
std::reverse_copy(le, le + dataSize, be);

    OriginalL'auteur Mohammed Safwat