La multiplication de deux valeurs, et de les imprimer à l'écran (MSNA, Linux)

Je lis que pour effectuer entier/flottant point de division sur un registre, le registre(s) d'être réalisée sur le fait initialized. Je suis curieux de ce que le bon assembleur de la directive est de le faire. Dois-je simplement fournir une adresse par quelque chose comme:

mov ecx, 0x65F ;0x65F represents an address for ecx to point to.

Et puis, en temps voulu (plus tard dans le code) faire quelque chose comme:

mov byte [ecx], 0xA ;move the value of 0xA into the contents of ecx, using only a byte's worth of data

Est-ce la bonne façon d'effectuer une telle opération? Si non, qu'est-ce que?

Mise à jour

Ok, donc ce que je suis en train de faire est fondamentalement multiplier deux valeurs et de les imprimer à l'écran.
Le code est comme suit, et pour quelque raison que chaque fois que j'essaie de diviser edx j'obtiens une erreur de segmentation ou une virgule flottante arithmatic exception. Quelqu'un pourrait-il m'expliquer ce que c'est ce que je fais mal?

Code

section .data
    counter: db 0xA                         ;store value 10 in 'counter', while allocating only one byte. This will be used for decrementing purposes
section .bss
    valueToPrint: resb 4                    ;alloc 4 bytes of data in 'valueToPrint'

section .text

global _start

_print_char:                    
    add eax, '0'                ;convert to ascii
    mov [valueToPrint], eax     ;store contents of 'eax' in valueToPrint
    mov eax, 4                  ;syswrite
    mov ebx, 1                  ;stdout
    mov ecx, valueToPrint       ;machine will take whatever value exists in 'ecx' and print
    mov edx, 1                  ;print only a single byte's worth of data
    int 0x80                    ;invoke kernel to perfrom instruction
    ret                         

_convert_values:
    mov edx, 0xA                ;dividing eax by 10, which will lower its tens place
    div edx                     ;(**Program crash here**)do division: remainder SHOULD be stored in edx
    mov byte [edx], 0x0         ;zero out edx       
    call _print_char            ;do printing for latest character
    dec byte [counter]          ;decrement counter
    mov dword [eax], counter    ;store counter in eax
    jnz _convert_values         ;while eax > 0 continue process

_endl:
    mov eax, '\n'               ;store newline character in eax to be printed
    call _print_char            ;print value
    ret                 

_mul:
    mov eax, 0x2A ;store 42 in eax
    mov edx, 0x2B ;store 43 in edx
    mul edx       ;multiply [eax] * [edx]
    ret

_safe_exit:
    mov eax, 1  ;initiate 'exit' syscall
    mov ebx, 0  ;exit with error code 0
    int 0x80    ;invoke kernel to do its bidding 

_start:
    nop                             ;used to keep gdb from complaining

    call _mul                       ;multiply the values
    call _convert_values            ;do hex to ascii conversion

    jmp _safe_exit                  ;use jmp as opposed to call since it technically doesn't 'ret'
  • Veuillez expliquer exactement ce que vous essayez d'accomplir. Oui, de mémoire et/ou des registres doit être réglé à des valeurs valides pour obtenir des instructions pour faire quelque chose de valable - ce n'est pas différent de variables dans un langage de haut niveau. Votre première instruction définit simplement le registre ecx à 0x65f, la deuxième on stocke un octet de 0xa dans ce ecx points.
  • Mis à jour; j'apprécie l'assistance.
  • Voir: stackoverflow.com/questions/9793060/... Vous avez besoin à zéro edx avant d'émettre la div instruction.
  • Et voici un autre avec le même problème: stackoverflow.com/questions/10343155/...
  • Comment avez-vous "zéro" edx, exactement? Si je comprends bien, détruisant un registre désigne la réinitialisation de la moitié supérieure de l'octet. Est-ce exact? J'ai essayé les deux and et xor sur edx et aucune n'a fonctionné. Les instructions fournies dans les deux de ces questions/réponses n'ont pas aidé malheureusement.
  • Il existe de nombreuses façons de "zéro", un registre si elle ne contient pas encore de 0: une façon est d'xor par lui-même, un autre pour déplacer de 0, un troisième pour le remplacer par le contenu d'un emplacement mémoire qui contient 0 ou le remplacer par le contenu d'un autre registre qui contient déjà 0.

InformationsquelleAutor zeboidlund | 2012-06-29