Discussion :

[doomtn]

Bonjour a tous

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[edfed]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Stabia]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

[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

[Neitsa]

Bonjour,

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.

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

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.

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)

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.

[doomtn]

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