Décalage à droite

Version imprimable

Décalage à droite

Bonjour a tous

La fonction suivante fait un décalage a droite de n bits dans un mot de 64 bit

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
static inline Word64 SAR64(Word64 x, int n)
{
        unsigned int xLo = ((unsigned int *)&x)[0];
        int xHi = ((int *)&x)[1];
        unsigned char nb = (unsigned char)n;
 
        if (n < 32) {
                   __asm {
                             mov edx, xHi
                             mov eax, xLo
                             mov cl, nb
                             shrd eax, edx, cl
                             sar edx, cl
                             }
 
 
          } else if (n < 64) {   */
                   /* sar masks cl to 0x1f */
                    /*__asm {
                              mov edx, xHi
                              mov eax, xHi
                              mov cl, nb
                              sar edx, 31
                              sar eax, cl
                                 }
                 } else {
                            __asm {
                                      sar xHi, 31
                                      mov eax, xHi
                                      mov edx, xHi
                                      }
                          }
       
}

Pouvez m'aidez a traduire cette fonction en C

Merci d'avance

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ;assume param1, param2=qword to shift ;assume param3=qword shift value ;assume escuze c'est une habitude, j'ecrit toujour en anglais dans les codes sources sarC: mov ebp,esp mov ecx,[ebp-4] mov eax,[ebp-12] mov edx,[ebp-8] cmp ecx,32 jl .32 .64: nia nia nia ret .32: nia nia nia 32 ret
ensuite, il faut compiler et inclure le binaire dans le code C, pour ça, je peu rien pour toi, je ne code pas en C, question d'hetique personnelle. :D

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
/*
- un exemple qui n'utilise pas UNIT64 ou __int64
- volontairement et intégralement écrit en C
- fonctionne avec un nombre quelconque de décalages (y compris 0)
*/
 
struct ent64
{
	int fort;
	int faible;
}
 
void decaleAdroite(ent64* valeur, int nb)
{
	int temoin;
 
	nb &= 0x3F;	// prudence : pas plus de 63 décalages
 
	for(b = 0; b < nb; b++)
	{
		temoin = valeur.fort & 0x00000001;
		valeur.fort >>= nb;
		valeur.faible >>= nb;
		valeur.faible |= temoin;
	}
}

Sinon "qui perd sa langue perd son âme"; il ne saurait y avoir d'éthique sans rigueur et sans respect de soi et de sa culture (donc de sa langue).

13/01/2008, 15h26
edfed

pourquoi pas plus de 63 decalages?
en asm, on peu faire autant de decalages que l'on veu. ce qui a pour effet d'effacer la donnée.

puis, je ne vois pas ce que vien faire du c chez mr asm
13/01/2008, 16h14
Neitsa

Bonjour,

Citation:

Envoyé par edfed

pourquoi pas plus de 63 decalages?
en asm, on peu faire autant de decalages que l'on veu. ce qui a pour effet d'effacer la donnée.

D'accord, mais il ne faut pas oublier que quoi qu'il arrive, le processeur fait un masque sur le décalage.

:arrow: En 32 bits, on reste limité à une limite de 5 bits armés pour le décalage (11111b = 0x1F = 31) :

Citation:

Envoyé par Manuel Intel

IA-32 processors (starting with the Intel 286 processor) do mask the shift count to 5 bits, resulting in a maximum count of 31. This masking is done in all operating modes (including the virtual-8086 mode) to reduce the maximum execution time of the instructions.

:arrow: En 64 bits, la taille par défaut des instructions de décalage reste de 32 bits (donc, limite à 5 bits armé), sauf avec un préfixe REX.W qui passe l'instruction à 64 bits. Dans ce cas là, le processeur fait un masque sur le décalage et la limite s'établit à 6 bit armés (111111b = 0x3F = 63)

Citation:

Envoyé par Manuel Intel

The count is masked to [...] 6 bits if in 64-bit mode and REX.W is used)

Le masque fait par Stabia me paraît légitime du fait que ça reste en adéquation avec ce que ferait le proco sur un QWORD, d'autant plus qu'en C ou C++, ça évite à la boucle de mouliner pour rien au delà de 63.
16/01/2008, 00h02
doomtn

Bonjour

merci a vous tous

Stabia pouvez vous me dire comment trouver les 32 bits du poids fort et les 32 bits du poids faible en utilisant le type long long au lieu de la structure ent64 :?

merci d'avance
16/01/2008, 10h13
Stabia

faire ou aider ?
1/ en assembleur c'est enfantin (nous sommes sur un forum ASM)

2/ en C cela va dépendre de ce que votre compilateur accepte et de votre machine (32 ou 64 bits)
Code:

1 2 3 4 5 6 7 UNIT64 valeur64 = 0x123456789ABCDEF0; UINT64 provisoire; int resultat: provisoire = valeur64; provisoire >>= 32; resultat = (int) provisoire;
OU (microsoft par exemple, mais interdit en aéronautique !)

Code:

resultat = (int) (provisoire >> 32);

3/ je ne sais pourquoi vous avez besoin de cela, mais si vous êtes étudiant s'enquérir de la solution n'est pas une bonne méthode : un jour ou l'autre vous serez confronter à une réalité plus rude.

Voila mon code je pense que sa marche pas pour un décalage >31 bits ce code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
typedef long long Word64;
 
static inline Word64 sar64(Word64 valeur, int nb)
{ int temoin,b;
  Word64 provisoir;
  unsigned int poidfort,poidfaible;
 
   provisoir=valeur;
   provisoir>>=32;
   poidfort=(int)provisoir;
 
   provisoir=valeur;
   poidfaible=(int)provisoir;
 
 
 
	nb &= 0x3F;	// prudence : pas plus de 63 décalages
 
	for(b = 0; b < nb; b++)
	{
		temoin = poidfort & 0x00000001;
		poidfort >>= nb;
		poidfaible >>= nb;
		poidfaible |= temoin;
 
	}
 
 
        provisoir=0;
        provisoir=poidfort;
        provisoir<<=32;  
        provisoir+=poidfaible;
 
        return provisoir;
}

Si quelqu'un peut me suggérer des modification
merci

16/01/2008, 21h34
doomtn

Citation:

Envoyé par Stabia

1/ en assembleur c'est enfantin (nous sommes sur un forum ASM)

2/ en C cela va dépendre de ce que votre compilateur accepte et de votre machine (32 ou 64 bits)

UNIT64 valeur64 = 0x123456789ABCDEF0;
UINT64 provisoire;
int resultat:

provisoire = valeur64;
provisoire >>= 32;
resultat = (int) provisoire;

OU (microsoft par exemple, mais interdit en aéronautique !)

resultat = (int) (provisoire >> 32);

3/ je ne sais pourquoi vous avez besoin de cela, mais si vous êtes étudiant s'enquérir de la solution n'est pas une bonne méthode : un jour ou l'autre vous serez confronter à une réalité plus rude.

1)Moi je développe sur ARM
2)ARM accepte les valeurs en 64 bits
3)Je suis pas étudiant mais faute de temps j'ai pas pu me concentrer sur ce code,en plus je maitrise pas bien l'assembleur PC.
A chaque un sa spécialité ;)
27/01/2008, 02h39
doomtn

Sa marche pas :cry:

Citation:

Envoyé par doomtn

Voila mon code je pense que sa marche pas pour un décalage >31 bits ce code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
typedef long long Word64;
 
static inline Word64 sar64(Word64 valeur, int nb)
{ int temoin,b;
  Word64 provisoir;
  unsigned int poidfort,poidfaible;
 
   provisoir=valeur;
   provisoir>>=32;
   poidfort=(int)provisoir;
 
   provisoir=valeur;
   poidfaible=(int)provisoir;
 
 
 
	nb &= 0x3F;	// prudence : pas plus de 63 décalages
 
	for(b = 0; b < nb; b++)
	{
		temoin = poidfort & 0x00000001;
		poidfort >>= nb;
		poidfaible >>= nb;
		poidfaible |= temoin;
 
	}
 
 
        provisoir=0;
        provisoir=poidfort;
        provisoir<<=32;  
        provisoir+=poidfaible;
 
        return provisoir;
}

J'en profite pour recoller ce code (voir les fonctions shl et shr pour les décalages). Si quelque chose t'échappes, n'hésites pas à poser des questions.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
/* 
 
A compiler avec -std=c99
 
On supposera ici qu'un long long tient exactement sur 64 bits
pour que les fonctions lsd et msd soit sémantiquement correctes.
 
*/
 
 
#include <stdio.h>
#include <stdlib.h>
 
 
/* shift left */
inline long long shl (long long x, unsigned char bitcount);
/* shift right */
inline long long shr (long long x, unsigned char bitcount);
/* most significant 32 bits (dword) */
inline int msd (long long x);
/* less significant 32 bits (dword) */
inline int lsd (long long x);
 
int main(void)
{
    long long x = 0xA12345674LL;
    unsigned char  bitcount = 4;
 
    /* Attention !!! : spécificateur de format MinGW pour long long !!! */
    printf("Nombre : %I64X\n", x);
    printf("Nombre décalé vers la gauche de 4 bits : %I64X\n", shl(x, bitcount));
    printf("Nombre décalé vers la gauche de 4 bits : %I64X\n", shr(x, bitcount));
    printf("32 bits de la partie haute : %08X\n", msd(x));
    printf("32 bits de la partie basse : %08X\n", lsd(x));
 
    return 0;
}
inline long long shl (long long x, unsigned char bitcount)
{
    bitcount &= 0x3F;
    return (x << bitcount);
}
 
inline long long shr (long long x, unsigned char bitcount)
{
    bitcount &= 0x3F;
    return (x >> bitcount);
}
 
inline int msd (long long x)
{
    return (x >> 32);
}
 
inline int lsd (long long x)
{
    return (x & 0xFFFFFFFF);
}

Citation:

Envoyé par Neitsa

J'en profite pour recoller ce code (voir les fonctions shl et shr pour les décalages). Si quelque chose t'échappes, n'hésites pas à poser des questions.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
/* 
 
A compiler avec -std=c99
 
On supposera ici qu'un long long tient exactement sur 64 bits
pour que les fonctions lsd et msd soit sémantiquement correctes.
 
*/
 
 
#include <stdio.h>
#include <stdlib.h>
 
 
/* shift left */
inline long long shl (long long x, unsigned char bitcount);
/* shift right */
inline long long shr (long long x, unsigned char bitcount);
/* most significant 32 bits (dword) */
inline int msd (long long x);
/* less significant 32 bits (dword) */
inline int lsd (long long x);
 
int main(void)
{
    long long x = 0xA12345674LL;
    unsigned char  bitcount = 4;
 
    /* Attention !!! : spécificateur de format MinGW pour long long !!! */
    printf("Nombre : %I64X\n", x);
    printf("Nombre décalé vers la gauche de 4 bits : %I64X\n", shl(x, bitcount));
    printf("Nombre décalé vers la gauche de 4 bits : %I64X\n", shr(x, bitcount));
    printf("32 bits de la partie haute : %08X\n", msd(x));
    printf("32 bits de la partie basse : %08X\n", lsd(x));
 
    return 0;
}
inline long long shl (long long x, unsigned char bitcount)
{
    bitcount &= 0x3F;
    return (x << bitcount);
}
 
inline long long shr (long long x, unsigned char bitcount)
{
    bitcount &= 0x3F;
    return (x >> bitcount);
}
 
inline int msd (long long x)
{
    return (x >> 32);
}
 
inline int lsd (long long x)
{
    return (x & 0xFFFFFFFF);
}

Merci Neitsa :D
Finalement je crois que je vais utilisé l'opérateur >>.
J'ai juste une dernière question, de point de vue performance(temps d'execution...) est ce qu'il y a une grande différence entre la version en assembleur et la version en C ?

28/01/2008, 05h48
grandv

Il ne faut pas oublier le unsigned long long.
Le signe n'est jamais marrant dans les décalages, d'autant plus que le code initial était non signé.