MSNA de l'Assemblée convertir les données d'entrée à l'entier?

Ok, donc je suis assez nouveau à l'assemblée, enfait, je suis très nouveau à l'assemblée. J'ai écrit un bout de code qui veut simplement prendre numériques d'entrée de l'utilisateur, de le multiplier par 10, et avoir le résultat est exprimé à l'utilisateur par le biais de programmes de statut de sortie (en tapant echo $? dans le terminal)
Le problème est qu'il n'est pas de donner le nombre exact, 4x10 a montré que 144. Alors j'ai pensé que l'entrée serait probablement aussi un personnage, plutôt que d'un entier. Ma question est, comment puis-je convertir la saisie de caractères pour un nombre entier de sorte qu'il peut être utilisé dans des calculs arithmétiques?

Ce serait génial si quelqu'un pouvait répondre en gardant à l'esprit que je suis un débutant 🙂
Aussi, comment puis-je convertir dit entier retour à un personnage?

section .data

section .bss
input resb 4

section .text

global _start
_start:

mov eax, 3
mov ebx, 0
mov ecx, input
mov edx, 4
int 0x80

mov ebx, 10
imul ebx, ecx

mov eax, 1
int 0x80

J'ai réussi à comparer l'entrée de l'utilisateur à un nombre avec: mov ecx, dword[input] est-ce réellement changer la valeur de ecx à un nombre entier? et comment fait-on revenir à une chaîne de caractères?

OriginalL'auteur user2862492 | 2013-10-11

Voici un couple de fonctions pour la conversion de chaînes en nombres entiers, et vice-versa:

; Input:
; ESI = pointer to the string to convert
; ECX = number of digits in the string (must be > 0)
; Output:
; EAX = integer value
string_to_int:
  xor ebx,ebx    ; clear ebx
.next_digit:
  movzx eax,byte[esi]
  inc esi
  sub al,'0'    ; convert from ASCII to number
  imul ebx,10
  add ebx,eax   ; ebx = ebx*10 + eax
  loop .next_digit  ; while (--ecx)
  mov eax,ebx
  ret


; Input:
; EAX = integer value to convert
; ESI = pointer to buffer to store the string in (must have room for at least 10 bytes)
; Output:
; EAX = pointer to the first character of the generated string
int_to_string:
  add esi,9
  mov byte [esi],STRING_TERMINATOR

  mov ebx,10         
.next_digit:
  xor edx,edx         ; Clear edx prior to dividing edx:eax by ebx
  div ebx             ; eax /= 10
  add dl,'0'          ; Convert the remainder to ASCII 
  dec esi             ; store characters in reverse order
  mov [esi],dl
  test eax,eax            
  jnz .next_digit     ; Repeat until eax==0
  mov eax,esi
  ret

Et c'est de cette façon que vous souhaitez utiliser:

STRING_TERMINATOR equ 0

lea esi,[thestring]
mov ecx,4
call string_to_int
; EAX now contains 1234

; Convert it back to a string
lea esi,[buffer]
call int_to_string
; You now have a string pointer in EAX, which
; you can use with the sys_write system call

thestring: db "1234",0
buffer: resb 10

Noter que je ne fais pas beaucoup de contrôle d'erreur dans ces routines (comme vérifier si il y a des caractères en dehors de la plage '0' - '9'). Ni les routines de manipuler des nombres signés. Donc, si vous avez besoin de ces choses que vous aurez à ajouter vous-même.

Merci de ne pas recommander la lenteur de la loop instruction! Aussi, 2 LEA instructions sont nettement mieux que imul + add: lea ebx, [4*ebx + ebx] (ebx*=5) / lea ebx, [eax + 2*ebx]. Ou avez-vous été l'optimisation du code-taille? sub al,'0' enregistre 1 octet sur sub eax,'0', mais provoque une partielle-registre de décrochage sur Nehalem/Core2 et encore pire sur PIII. (Bien sur Sandybridge; c'est un RMW de AL, afin de ne pas renommer l'partielle reg séparément de EAX.)
Et si vous n'avez pas besoin de vérifier pour être valide d'un chiffre décimal comme une condition de boucle, vous pouvez lea ebx, [eax + 2*ebx - '0'] " pour éviter la sub entièrement, mais ce qui permettrait d'augmenter la LEA de latence de 3 sur les Processeurs Intel.

OriginalL'auteur Michael

2

La base algorith pour chaîne->chiffre est: total = total*10 + digit, à partir de la MSD. Si la gauche de la plus /Plus Importante /premier chiffre (de mémoire, et dans l'ordre de lecture) est multiplié par 10 N fois, où N est le nombre total de chiffres après.

Cette façon de faire est généralement plus efficace que de multiplier chaque chiffre par la droite de la puissance de 10 avant d'ajouter. Qui aurait besoin de 2 multiplie; on de cultiver une puissance de 10, et un autre pour l'appliquer aux chiffres. (Ou une table look-up avec croissant des puissances de 10).

Bien sûr, pour plus d'efficacité, vous pouvez utiliser SSSE3 pmaddubsw et SSE2 pmaddwd de multiplier les chiffres par leur place-valeur en parallèle: voir Comment mettre en œuvre atoi à l'aide SIMD?. Ce n'est probablement pas une victoire quand les nombres sont généralement courte, si. Un scalaire boucle est efficace quand la plupart des numéros sont à seulement quelques chiffres.

Ajoutant à @Michael réponse, il peut être utile d'avoir l'int->fonction de chaîne arrêter à la première non-chiffres, au lieu d'une longueur fixe. Cela permettra de repérer les problèmes comme votre chaîne, y compris un retour à la ligne à partir de quand l'utilisateur appuie sur le retour, ainsi que de ne pas se 12xy34 dans un très grand nombre. (La traiter comme 12, comme C est atoi function). Le caractère de fin peut également être appelé à disparaître 0 dans un C implicite chaîne de longueur.

J'ai aussi fait quelques améliorations:
- Ne pas utiliser la lenteur de boucle enseignement sauf si vous êtes l'optimisation de code de taille. Juste oublier qu'il existe et utiliser dec /jnz dans le cas où le compte à rebours à zéro est toujours ce que vous voulez faire, au lieu de comparer un pointeur ou quelque chose d'autre.
- 2 LEA instructions sont nettement mieux que imul + add: la faible latence.
- accumuler le résultat dans EAX où nous voulons revenir de toute façon. (Si vous inline cela au lieu de l'appeler, quel que soit le registre, vous voulez le résultat.)
J'ai changé les registres il s'ensuit donc le x86-64 V ABI (Premier arg à RDI, de retour dans EAX).

Portage à 32 bits: Cela ne dépend pas de 64 bits à tous; qu'il peut être porté à 32 bits en utilisant simplement les registres 32 bits. (c'est à dire remplacer rdi avec edi, rax avec ecx, et rax avec eax). Méfiez-vous de l'appel C-convention de différences entre les versions 32 et 64 bits, par exemple, l'EDI est préservée et les arguments sont généralement passés sur la pile. Mais si votre interlocuteur est l'asm, vous pouvez passer d'un arg en EDI.
```
    ; args: pointer in RDI to ASCII decimal digits, terminated by a non-digit
    ; clobbers: ECX
    ; returns: EAX = atoi(RDI)  (base 10 unsigned)
    ;          RDI = pointer to first non-digit
global base10string_to_int
base10string_to_int:

     movzx   eax, byte [rdi]    ; start with the first digit
     sub     eax, '0'           ; convert from ASCII to number
     cmp     al, 9              ; check that it's a decimal digit [0..9]
     jbe     .loop_entry        ; too low -> wraps to high value, fails unsigned compare check

     ; else: bad first digit: return 0
     xor     eax,eax
     ret

     ; skew the loop so we can put the JCC at the bottom where it belongs
     ; but still check the digit before messing up our total
  .next_digit:                  ; do {
     lea     eax, [rax*4 + rax]    ; total *= 5
     lea     eax, [rax*2 + rcx]    ; total = (total*5)*2 + digit
       ; imul eax, 10  /add eax, ecx
  .loop_entry:
     inc     rdi
     movzx   ecx, byte [rdi]
     sub     ecx, '0'
     cmp     ecx, 9
     jbe     .next_digit        ; } while( digit <= 9 )

     ret                ; return with total in eax
```
Cela empêche la conversion sur le premier non-chiffre. Souvent, ce sera l'0 octet qui met fin à un implicite chaîne de longueur, mais vous pourriez vérifier après la boucle qui ecx == -'0' si vous voulez détecter se terminant sur un autre chiffre. Si votre entrée est explicite-chaîne de longueur, vous aurez besoin d'utiliser un compteur de boucle, au lieu de vérifier un terminator (comme @Michael réponse), parce que le prochain octet dans la mémoire peut être un autre chiffre. Ou il pourrait être dans un unmapped page.

Prise de la première itération de spécial et de le manipuler avant de sauter dans la partie principale de la boucle est appelée boucle peeling. Éplucher la première itération, nous permet d'optimiser spécialement, parce que nous savons total=0 donc il n'y a pas besoin de multiplier tout par 10. C'est comme commencer avec sum = array[0]; i=1 au lieu de sum=0, i=0;.

Pour obtenir belle boucle de la structure (avec la branche conditionnelle en bas), j'ai utilisé l'astuce de sauter dans le milieu de la boucle pour la première itération. N'en est pas de même de prendre un supplément de jmp parce que j'étais déjà ramification dans le pelées première itération.

La manière la plus simple de résoudre le problème de la sortie de la boucle sur un chiffre serait d'avoir un jcc dans le corps de la boucle, comme un if() break; déclaration en C avant la total = total*10 + digit. Mais alors j'aurais besoin d'une jmp et ont 2 total de la branche d'instructions dans la boucle, ce qui signifie plus de frais généraux.

Si je n'ai pas besoin de la sub ecx, '0' résultat de la condition de la boucle, j'aurais pu utiliser lea eax, [rax*2 + rcx - '0'] qu'elle fasse partie de la LEA ainsi. Mais qui aurait fait de la LEA de latence de 3 cycles au lieu de 1, sur Sandybridge-famille de Processeurs. (3-composante LEA vs 2 ou moins.) Les deux Lea former une boucle transportées à la chaîne de dépendances sur eax (total), donc (surtout pour les grands nombres) il ne serait pas utile sur Intel. Sur les Processeurs où base + scaled-index est pas plus rapide que base + scaled-index + disp8 (Bulldozer-famille /Ryzen), alors bien sûr, si vous avez une longueur explicite en tant que votre condition de boucle et ne veulent pas les chiffres.

J'ai utilisé movzx à charger avec zéro extension en premier lieu, au lieu de le faire après la conversion de l'chiffres du code ASCII en entier. (Il doit être fait à un certain point à ajouter dans le 32 bits EAX). Souvent le code qui manipule les chiffres ASCII utilise octet de l'opérande de taille, comme mov cl, [rdi]. Mais ce serait une fausse dépendance sur l'ancienne valeur de RCX sur la plupart des Processeurs.

sub al,'0' enregistre 1 octet sur sub eax,'0', mais provoque une partielle-registre de décrochage sur Nehalem/Core2 et encore pire sur PIII. Fine sur toutes les autres familles de CPU, même Sandybridge: c'est un RMW de AL, afin de ne pas renommer l'partielle reg séparément de EAX. Mais cmp al, 9 ne cause pas un problème, parce que la lecture d'un octet de registre est toujours beau. Il enregistre un octet (un encodage sans ModRM octet), j'ai donc utilisé que dans le haut de la fonction.

Pour une meilleure optimisation des trucs, voir http://agner.org/optmize, et d'autres liens dans le x86 balise wiki.

La balise wiki a aussi débutant liens, y compris une section FAQ avec des liens vers entier->fonctions de chaîne, et d'autres questions de débutant.

Connexes: Comment puis-je imprimer un nombre entier au Niveau de l'Assemblée de la Programmation sans printf de la bibliothèque c? est l'inverse de cette question, entier -> base10string.

OriginalL'auteur Peter Cordes

Vous devez vous connecter pour publier un commentaire.