Unité A6: Conversions. Unité A6: Conversions

Dimension: px

Commencer à balayer dès la page:

Download "Unité A6: Conversions. Unité A6: Conversions"

André Larivière
il y a 6 ans
Total affichages :

1 Objectifs : À la fin de cette unité, vous saurez comment on peut programmer en assembleur les conversions usuelles binaire décimal et décimal binaire. Pour y parvenir, vous devrez atteindre les objectifs suivants : - décrire les principaux algorithmes de conversion entre le décimal et le binaire. Pierre Marchand, On effectue souvent en assembleur les conversions élémentaires de binaire à décimal et vice-versa, parce que ces fonctions sont appelées très souvent et ont donc intérêt à être performantes. La conversion entre le décimal et le binaire s'effectue habituellement comme suit : Décimal (BCD) à binaire (voir supplément au volume, section 3.3.1) : R = d + 10 R Pour la conversion binaire à décimal, trois méthodes sont fréquemment utilisées : R = b + 2 R en arithmétique BCD Divisions répétées par 10 -> séquence de restes Tables Celle qu'on choisit dépend du processeur utilisé, du jeu d'instructions dont il dispose, et du temps d'exécution de chacune. Pierre Marchand,

2 9.1 Conversion décimal à binaire Effectuons la conversion d'une chaîne de caractères décimaux représentant un nombre positif vers un nombre binaire de 32 bits non signé. On utilise l algorithme d + 10 x R. Exemple sur 16 bits : Nombre à convertir en BCD R = A x 0000 = A x 0001 = 000C A x 000C = 007B A x 007B = 04D2 Pierre Marchand, Conversion décimal à binaire dec2long proc decstring:lpstr mov esi, decstring xor eax, eax ; résultat = 0 While: movzx ebx, byte ptr[esi] ; while (*decstring++) inc esi test bl, bl ; terminé si nul je fin sub bl, '0' ; conversion ASCII-binaire imul eax, 10 ; résultat *= 10 add eax, ebx ; résultat += digit jmp While fin: ret ; résultat dans eax dec2long endp Pierre Marchand,

3 1 e méthode : divisions par 10 Exemple sur 16 bits : ABCD / 000A = 112E reste E / 000A = 01B7 reste 08 01B7 / 000A = 002B reste B / 000A = 0004 reste / 000A = 0000 reste 04 Résultat : en BCD, en ASCII, ou Pierre Marchand, e méthode : divisions par 10 Stratégie : comme le résultat est la séquence des restes, mais inversée, nous écrirons ces restes vers la gauche à partir du 11e octet dans une variable Temp de 12 octets initialisée à 0. Nous aurons ainsi automatiquement notre caractère de fin de chaîne. Ainsi, dans l exemple précédent, on aurait : Temp : Pointeur à la fin des divisions Pointeur initial Il nous restera à incrémenter le pointeur final et à faire un strcopy vers la destination. Pierre Marchand,

4 1 e méthode : divisions par 10 temp db 12 dup(0) ; espace pour restes = 12 zéros bin2string proc n:dword, String:LPSTR mov eax, n ; nombre à convertir lea esi, temp add esi, 10 ; pointer sur fin de temp mov ecx,10 ; 10 pour la division divis: mov edx, 0 ; eax = quotient précédent div ecx ; diviser par 10 add dl, 0 ; convertir reste en ASCII mov [esi], dl ; stocker dans temp dec esi ; écrire le suivant à gauche Pierre Marchand, e méthode : divisions par 10 test eax, eax jne divis ; tant que quotient!= 0 ; copier temp dans destination inc esi ; pointer sur dernier reste mov edi, String ; adresse destination copy: lodsb ; reste suivant stosb test al, al ; tant que reste 0 jne ret bin2string endp copy Pierre Marchand,

5 2 e méthode : R = b + 2 * R Exemple sur 8 bits : Addition BCD Sur 2 octets R = = = = = = = = = Pierre Marchand, e méthode : R = b + 2 * R Exemple sur 8 bits : Il faut ensuite décompacter les octets pour les convertir en ASCII > > Pour décompacter, on met un octet du résultat dans al et dans ah : ax = On fait ensuite le AND de ax avec 0xF00F : and ax,0xf00f ax = Puis on décale ah de 4 bits vers la droite : shr ah, 4 ax = Finalement, on ajoute 0x30 à chacun : add eax,0x3030 ax = Pierre Marchand,

6 2 e méthode : R = b + 2 * R Comme un nombre de 32 bits peut aller jusqu à qui a 10 chiffres, il nous faudra faire nos additions BCD sur 5 octets (un octet contient 2 chiffres en BCD compacté. Pierre Marchand, e méthode : R = b + 2 * R temp db 5 dup(0) bin2decstring proc n:dword, decstring:lpstr mov ebx, n mov edx, 32 ; 32 bits à traiter lea edi, temp decal: rcl ebx, 1 ; mettre le msb dans CF mov esi, 4 mov ecx, 5 Pierre Marchand,

7 2 e méthode : R = b + 2 * R abcd: mov al, byte ptr [edi+esi ; addition bcd sur 5 octets adc al, al ; b + 2 * R daa mov dec dec ; ajustement BCD byte ptr [edi+esi], al ; résultat dans temp esi ecx jne abcd ; fin abcd dec edx jne decal ; fin décal mov ecx, 5 mov esi, str Pierre Marchand, e méthode : R = b + 2 * R copy: mov al, [edi] ; copier dans destination et ; convertir le BCD compacté mov ah, al ; en BCD non compacté and ax, 0xF00F ; masquer lsb et msb shr ah, 4 ; décaler msb en place add ax, 0x3030 ; convertir en ASCII xchg ah, al ; little endian mov word ptr [esi], ax ; stocker deux car inc edi ; incrémenter source add esi, 2 ; incrémenter destination dec ecx jne copy mov byte ptr[edi], 0 ; car de fin de chaîne ret Pierre Marchand,

8 3 e méthode : à l aide d'une table Soit n le nombre à convertir. Le résultat r est un nombre de 10 chiffres ASCII qu on initialise à 0 : r = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 Tant que n >= , n = n , r[0] = r[0] + 1 Tant que n >= , n = n , r[1] = r[1] + 1 Tant que n >= , n = n , r[2] = r[2] + 1 Tant que n >= , n = n , r[3] = r[3] + 1 Tant que n >= , n = n , r[4] = r[4] + 1 Tant que n >= 10000, n = n , r[5] = r[5] + 1 Tant que n >= 1000, n = n , r[6] = r[6] + 1 Tant que n >= 100, n = n - 100, r[7] = r[7] + 1 Tant que n >= 10, n = n - 10, r[8] = r[8] + 1 r[9] = n Pierre Marchand, e méthode : à l aide d'une table Table dd , , , , , dd 10000, 1000, 100, 10, 1 bin2decstring proc n:dword, decstring:lpstr mov eax, n lea esi, Table xor ebx, ebx mov edi, decstring mov ecx, 10 ; 10 nombres dans Table digit: mov byte ptr [edi+ebx], 0 ; résultat = 0 mov edx, dword ptr [esi+ebx*4] ; Table[i] comp: cmp eax, edx ; peut-on soustraire? jb suiv Pierre Marchand,

9 3 e méthode : à l aide d'une table sub eax. edx ; soustraire Table[i] add byte ptr [edi+ebx], 1 ; incrémenter résultat jmp comp ; tant que eax > Table[i] suiv: inc ebx ; élément suivant loop digit mov byte ptr [edi+ebx], 0 ; car de fin de chaîne ret bin2decstring endp Pierre Marchand, Certains raffinements pourraient s'avérer souhaitables dans les programmes présentés dans cette section. Notamment : Conversion décimal-binaire Traitement des nombres négatifs Traitement des espaces au début Conversion binaire-décimal Traitement des nombres négatifs Éliminer les zéros initiaux, par exemple, retourner 3 au lieu de Pierre Marchand,

10 9.3 Conversion binaire à chaîne hexadécimale Pour effectuer cette conversion, on effectue une rotation de eax de 4 bits vers la gauche pour mettre les 4 bits les plus significatifs à droite On copie al dans bl. On masque ensuite les 4 bits de poids fort de bl avec : and bl, 0x0F On ajoute 0x30 à bl pour le convertir en ASCII : add bl, 0x On écrit bl dans le résultat et on incrémente le pointeur. On effectue cette opération 8 fois. Pierre Marchand, Conversion binaire à chaîne hexadécimale Long2HexString proc num:dword, HexString:LPSTR mov edi, HexString mov eax, num mov ecx, 8 ; 8 car. pour représenter un long lp: rol eax, 4 ; 4 bits suivants mov bl, al and bl, 0x0F ; masquer les 4 bits de droite add bl, 0 ; convertir en ASCII cmp bl, 9 jbe ok ; si c est un chiffre 0-9 add bl, 7 ; si c est une lettre A-F Pierre Marchand,

11 9.3 Conversion binaire à chaîne hexadécimale ok: mov [edi],bl ; placer dans la chaîne inc edi dec ecx jnz lp mov byte ptr [edi], 0 ; caractère de fin de chaîne ret long2hexstring endp Pierre Marchand, Conversion binaire à chaîne hexadécimale Une autre façon d effectuer cette conversion utilise une table de 16 entrées contenant les codes ASCII des chiffres et des lettres correspondant aux nombres hexadécimaux 0 à F. On place le nombre à convertir dans edx. On effectue comme dans la façon précédente une rotation vers la gauche de edx, et on copie dl dans al. On masque les 4 bits de poids fort. Ensuite on se sert de al comme indice dans la table de 16 codes ASCII. L instruction XLAT remplace al par le contenu de [ebx + al]. Par exemple, 0x0B donnera le code 0x42 = B. On écrit ensuite al dans le résultat et on incrémente le pointeur. Pierre Marchand,

12 9.3 Conversion binaire à chaîne hexadécimale table db ' ABCDEF' Long2HexString proc num:dword, HexString:LPSTR mov edi, HexString lea ebx, table ; table de traduction dans ebx mov ecx, 8 ; toujours 8 car. mov edx, num ; nombre à convertir lp: rol edx, 4 ; digit suivant mov al, dl and al, 0x0F ; garder 4 bits seulement xlat ; traduire mov [edi], al ; écrire dans destination Pierre Marchand, Conversion binaire à chaîne hexadécimale inc edi dec ecx jne lp move byte ptr [edi], 0 ; caractère de fin de chaîne ret Long2HexString endp Pierre Marchand,

Documents pareils

Assembleur i8086. Philippe Preux IUT Informatique du Littoral. Année universitaire 95 96

Assembleur i8086. Philippe Preux IUT Informatique du Littoral. Année universitaire 95 96 Assembleur i8086 Philippe Preux IUT Informatique du Littoral Année universitaire 95 96 1 Avertissement Ce document décrit le langage d assemblage étudié et utilisé dans le cadre des TP d architecture.