Inverser les octets d'un type double

Signaler
Messages postés
48
Date d'inscription
jeudi 26 avril 2007
Statut
Membre
Dernière intervention
10 décembre 2009
-
Messages postés
48
Date d'inscription
jeudi 26 avril 2007
Statut
Membre
Dernière intervention
10 décembre 2009
-
Bonjour,

Je souhaite tourner les octets de données de type double (probleme de big endian/ little endian).
Pour
des données de type long ou short pas de probleme mais pour les double
je ne vois pas trop comment faire ca propre. Le probleme viens du fait
que mon processeur ne gere pas les données de 64 bits.

Auriez vous une idee?

Je vous remercie.

5 réponses

Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
29
BYTE *pbt;

pbt = (BYTE*) &dbl;
te reste plus qu'à déplacer ce que tu veux.

ciao...
BruNews, MVP VC++
Messages postés
3874
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
7 novembre 2014
14
Salut,

Si on a la flemme de faire tous les déplacements, on peut aussi faire un peu d'assembleur. Pour VC :

__declspec(naked) void __stdcall SwapDouble(double* lpVal)
{
  __asm
  {
    mov edx, dword ptr [esp + 4]

    mov eax, dword ptr [edx]
    mov ebx, dword ptr [edx + 4]

    bswap eax
    bswap ebx

    mov dword ptr [edx], ebx
    mov dword ptr [edx + 4], eax

    ret 4
  }
}
Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
29
Tu es certain que c'est l'ordre des octets voulus ? moi aucune idée.

ATTENTION que EBX est à sauvegarder !!!
On va gagner empilage, dépilage et sauvegarde de EBX:


__declspec(naked) void __fastcall SwapDouble(double* lpVal)
{
  __asm {
    mov edx, dword ptr[ecx + 4]
    mov eax, dword ptr[ecx]
    bswap edx
    bswap eax
    mov dword ptr[ecx + 4], edx
    mov dword ptr[ecx], eax
    ret 0
  }
}

ciao...
BruNews, MVP VC++
Messages postés
3874
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
7 novembre 2014
14
Ah pardon. J'ai pris When using __asm to write assembly language in C/C++ functions, you don't need to preserve the EAX, EBX, ECX, EDX, ESI, or EDI registers au pied de la lettre sans réfléchir au fait qu'avec le naked, je devais me référer à la convention d'appel...

Pour l'ordre, il faut inverser les 8 octets il me semble.
Si je lance ntsd calc, je suis en little endian. J'entre une série de 8 octets (eb enter bytes). Je les affiche sous forme d'octets pour vérifier (db display bytes). Cela revient à faire un affichage en big endian : l'octet de poid fort en premier, ce qui paraît le plus intuitif/normal. Puis je les affiche sous forme de "double" (dq = display qword). Je les affiche aussi sous forme de dword et word tant qu'à faire.

Globalement, tous les octets sont inversés pour la taille du type "atomic".

0:000> eb esp 11 22 33 44 55 66 77 88
0:000> db esp L8
0007fb20  11 22 33 44 55 66 77 88                          ."3DUfw.
0:000> dq esp L1
0007fb20  88776655`44332211
0:000> dd esp L2
0007fb20  44332211 88776655
0:000> dw esp L4
0007fb20  2211 4433 6655 8877

Pour tout inverser, je propose de mettre les deux dwords dans des registres, inverser ces registres, puis inverser l'ordre dans lequel j'ai remis en place les dwords.

    mov edx, dword ptr[ecx + 4]
    mov eax, dword ptr[ecx]
    bswap edx
    bswap eax
    mov dword ptr[ecx + 4], eax
    mov dword ptr[ecx], edx
    ret 0
Messages postés
48
Date d'inscription
jeudi 26 avril 2007
Statut
Membre
Dernière intervention
10 décembre 2009

Oui c'est exactement ca.
J'avais deja pensé à utiliser l'adresse mémoire de ma donner pour swapper cele ci et je pense qu il y a pas d autre moyens. Du fait que le processeur travaille en 32 bits, il convertit le type double en deux int
Cela reviens donc à swapper les donner de deux int.
Une fois l'adresse mémoire gérer cest relativement simple.

Je vous remercie.