Comment tourner à droite une valeur 64 bits efficacement en assembleur ARM7?

Question

Les offres de set-ARM7 de commande des moyens efficaces pour Pivoter à droite des valeurs 32 bits par une quantité arbitraire en assembleur. Pour le 2ème opérande d'une opération, il est même « gratuitement » en spécifiant ROR #n comme levier de vitesses opérande, mais pour les entiers 64 bits support pas directement par le jeu d'instructions est donnée. Outre les cas particuliers de rotation de 1, 31, 33 ou 63 positions de bits (sans parler de 0 ou 32), je ne sais comment faire pivoter une valeur de 64 bits en utilisant quatre instructions (il est très facile , donc je ne l'écris pas ici). Dans les quatre cas particuliers, je peux réduire à trois instructions, mais je ne sais pas comment le faire en général. Voici donc ma question:

Étant donné une valeur de 64 bits dans deux registres, dire R0 et R1, est-il possible de tourner à droite cette valeur par n positions (pour arbitraire n ) avec juste trois instructions ARM7?

Answer 1

Si un registre (par exemple r4) se produit pour maintenir la constante appropriée magique (1 décalée vers la gauche par la quantité souhaitée gauche-rotation) Je pense que l'on peut le faire en deux instructions:

  umull r3,r2,r1,r4
  umlal r2,r3,r0,r4

Plus lent que d'utiliser quatre instructions à cycle unique, mais même si l'on doit charger r4 avec la constante appropriée, il est encore plus compact que les méthodes de quatre instruction.

Answer 2

S'il y a une solution à cela, gcc ne reconnaît pas:

unsigned long long int reg64 = random_value;
unsigned int n = shift_value;
reg64 = (reg64 >> (n%64)) | (reg64 << ((64-n)%64));

donne le résultat suivant:

n = 1:

MOVS R2, R0, LSR #1
MOV R3, R1, RRX
ORR R2, R2, R1, ASL #31

n = 2-31:

MOV R2, R0, LSR #n
ORR R2, R2, R1, ASL #32-n
MOV R3, R0, ASL #32-n
ORR R3, R3, R1, LSR #n

n = 33-62:

MOV R3, R0, ASL #64-n
ORR R3, R3, R1, LSR #n-32
MOV R2, R0, LSR, #n-32
ORR R2, R2, R1, ASL #64-n

n = 63:

ADDS R2, R0, R0
ADC R3, R1, R1
ORR R2, R2, R1, LSR #31