Discussion :

[doomtn]

Bonjour a tous

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

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 vous m'aider a traduire cette fonction en C

Merci d'avance

[Melem]

les instructions sal (ou shl) sont traduites en C par l'opérateur <<. Quant à l'opérateur >>, ca peut être sar ou shr selon l'implémentation. D'habitude on utilise ces opérateurs sur des entiers non signés dans ce cas on peut dire que << est l'équivalent de shl et >> l'équivalent de shr. S'il y a autre chose que tu ne comprends pas, c'est plus un problème de langage C, poste dans le forum Assembleur.

[ManProc]

Pourquoi ne pas implémenter ta propre fonction. Faire un décalage de n bits, c'est pas si difficile.

[doomtn]

Bonjour
je peut pas implémenter cette fonction parce que je travail sur l'ARM,
en plus je maitrise pas bien l'assembleur ARM.

[Melem]

Bonjour
je peut pas implémenter cette fonction parce que je travail sur l'ARM,
en plus je maitrise pas bien l'assembleur ARM.

Tu veux faire du C (code portable, indépendant de la machine) ou de l'assembleur ARM? En C il y a les opérateurs << et >> pour effectuer des décalages respectivement vers la gauche et vers la droite. Sinon il ya le forum assembleur si tu veux des instructions spécifiques à l'ARM.

[doomtn]

Tu veux faire du C (code portable, indépendant de la machine) ou de l'assembleur ARM? En C il y a les opérateurs << et >> pour effectuer des décalages respectivement vers la gauche et vers la droite. Sinon il ya le forum assembleur si tu veux des instructions spécifiques à l'ARM.

Mon code est conçue pour l'architecture ARM mais si quelqun peut me la traduire
en C je m'occupe du reste
Je maitrise pas bien l'assembleur et l'assembleur ARM c'est pour sa je veux traduire cette fonctions en C.
Mon problème est comment peut on obtenir les 32 bits de poids fort et 32 bits de poids faible d'un entier de type long long (64bits)

Merci d'avance

[Pierre Maurette]

Mon code est conçue pour l'architecture ARM mais si quelqun peut me la traduire
en C je m'occupe du reste
Je maitrise pas bien l'assembleur et l'assembleur ARM c'est pour sa je veux traduire cette fonctions en C.

Je ne connais rien à ARM. Et je pense qu'il va vous falloir vous renseigner un minimum pour mener à bien votre truc. Au moins vérifier la représentation des entiers signés, et le boutisme.
Etant donné que vous faites du SAR, c'est à dire un décalage à droite avec maintien et propagation du bit de signe, je ne sais même pas si votre question a un sens si la plateforme n'est pas en complément à 2. Il faudrait alors peut-être voir le but de ce décalage.
Ceci réglé, le problème va être que le >> sur un signé négatif a un comportement indéfini. Il faudrait alors tester le signe de l'entier vu comme un signé. Parce que attention, même si c'est un unsigned, votre programme en assembleur le décale comme un signé. En assembleur, ce sont les instructions qui sont signées ou non. S'il est positif, c'est à dire si le MSB est éteint, vous le décalez simplement. Sinon, vous changez son signe (multiplier par -1), vous le décalez, puis vous le changez à nouveau de signe. En espérant que ça marche sur une archi ARM.
Ceci dit, surtout si vous ciblez un nombre fini et faible d'architectures, je prendrais le temps de regarder l'assembleur ARM, les instructions x86 MOV et SAR étant basiques. Et je le ferais en assembleur. Je suis sans doute atypique, mais pour moi, c'est beaucoup plus robuste que les opérations de bit sur des signés en C...

Mon problème est comment peut on obtenir les 32 bits de poids fort et 32 bits de poids faible d'un entier de type long long (64bits)

En considérant que l'on sait que le long long fait 64 bits, et le int en fait 32, vous pouvez partir de:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
 
 
int main (void)
{
    unsigned long long a = 0x0000000700000002;
    unsigned* low = (unsigned*)&a;
    unsigned* high = low + 4;
 
    printf("%d  %d  %d\n",sizeof(long long), *low, *high);
    return EXIT_SUCCESS;
}

en sachant que ça marche sur une machine petit-boutienne.

[doomtn]

Bonjour
je suis arrivé a faire ce code, je pense que sa marche

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
35
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 vous suggèrerez des modification pour l'optimisation du code