Bonjour je me remet a l'asm bien que j'avais et ai toujours un tout petit niveau dans ce language et je bloque déjà.Je code en assembleur x8086 sous Linux.

Mon but est de faire une addition de deux chiffre saisie par l'utilisateur, mon problème réside dans le fait que le programme ne me sort pas la bon résultat de l'addition.

Voici le code :

 segment .data

msg_chiffre1 db "Veuillez entrer un chiffre : ", 0
len1 equ $ - msg_chiffre1

segment 	.bss
nbr1	resb	1
nbr2	resb	1
result  resb  1

segment		.text

global _start

_start :
	;affichage msg_chiffre1
	mov eax, 4
	mov ebx, 1
	mov ecx, msg_chiffre1
	mov edx, len1
	int 0x80

	;saisi utilisateur
	mov eax, 3
	mov ebx, 1
	mov ecx, nbr1
	mov edx, 2
	int 0x80

	;affichage msg_chiffre1
	mov eax, 4
	mov ebx, 1
	mov ecx, msg_chiffre1
	mov edx, len1
	int 0x80

	;saisi utilisateur 2nd chiffre
	mov eax, 3
	mov ebx, 1
	mov ecx, nbr2
	mov edx, 1
        int 0x80


	;convertion ASCII
	mov bl, 10
	div bl

	add al, 0x30
	mov [nbr2] , al

        ;affichage
	mov eax, 4
	mov ebx, 1
	mov ecx, nbr2
	mov edx, 1
	int 0x80


	;fin programme
	mov eax, 1
	mov ebx, 0

	int 0x80

Merci a vous , et bonne journéee, a+++

-
Edité par Code Rom 17 décembre 2018 à 11:43:08

Ça serait bien de donner une copie de ce qui se passe à l'exécution.

> j'ai aussi le même problème

Non c'est faux. Le premier programme affiche un résultat erroné

Veuillez entrer un chiffre : 2
Veuillez entrer un chiffre : 3
0

et le votre fait un accès mémoire illégal.

Erreur de segmentation

PS peut être à cause de confusions dans l'utilisation des registres.

Pour repartir d'un bon pied, voila un exemple qui (j'espère) respecte les conventions pour les appels syscall pour linux x86 64

Source affichage-syscall.asm

	;; ce programme utilise les syscalls pour
	;; - affichage d'un message
	;; - fin par exit(33)
	
	section .data
	
	;;  les conventions pour les appels
	;;  https://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

buffer	db "Hello, world", 10
count	equ $ - buffer 	
fd      equ 1                 	; sortie standard
	
section .text
	global _start

_start:
	mov rax, 1     	; syscall 1, write(fd, buffer, count)
	mov rdi, fd
	mov rsi, buffer
	mov rdx, count
	syscall 

	mov  rax, 60    ; syscall 60, exit(33)
	mov  rdi, 33
	syscall

En programmant en langage machine, on se perd très vite dans les nombreux détails, il est donc important de

• choisir avec soin les identificateurs pour s'y retrouver
• commenter pour savoir ce que fait chaque petit "paragraphe" de quelques instructions

Compilation

$ nasm  -f elf64 -g -F stabs affichage-syscall.asm -o affichage-syscall.o
$ ld affichage-syscall.o -o affichage-syscall

Exécution

$ ./affichage-syscall 
Hello, world

$ # on vérifie ce que retourne exit
$ echo $?
33

-
Edité par michelbillaud 25 mars 2024 à 17:42:49

Bien le bonjour,

content d'être de retour.

Concernant l'addition de deux nombres en assembleur x86.

Vous pouvez voir le code d'une calculatrice simple sur le lien suivant (le code fonctionnel est dans le dernier post) :

Créer une calculatrice simple en asm - x86 32-bits / 64-bits Assembleur (developpez.net)

Voici le code, ce sera plus simple. C'est pour assembleur x86 linux 64bits :

segment	.data
 
values db "Nombre1 et Nombre2 seront fixé en dur a chaque début d opération.",10, 0, 10
len_values equ $ - values
 
selection db "Entrez votre choix d'operation : ", 10, 0, 10
len_select equ $ - selection
 
addition db "1 Addition.", 10, 0
len_add equ $ - addition
 
soustraction db "2 Soustraction.", 10, 0
len_sous equ $ - soustraction
 
division db "3 Division.", 10, 0
len_div equ $ - division
 
multiplier db "4 Multiplication.", 10, 0, 10
len_multi equ $ - multiplier
 
choix db "Votre choix : ", 0
len_choix equ $ - choix
 
choix_add db "Vous avez choissis l addition de 10 + 15", 10, 0
len_choix_add equ $ - choix_add
 
choix_sous db "Vous avez choissis la soustraction de 5 - 2", 10, 0
len_choix_sous equ $ - choix_sous
 
choix_div db "Vous avez choissis la division de 27 / 9 ", 10, 0
len_choix_div equ $ - choix_div
 
choix_multi db "Vous avez choissis la multiplication !", 10, 0
len_choix_multi equ $ - choix_multi
 
 
result db "Le resultat de l'operation est : ", 0
len_result equ $ - result
 
 
segment	.bss
 
nbre1	resb	1
nbre2	resb	1
operation	resb	2
 
 
segment	.text
 
global _start
 
_start :
 
affichage:
	mov eax, 4
	mov ebx, 1
	mov ecx, values
	mov edx, len_values
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, selection
	mov edx, len_select
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, addition
	mov edx, len_add
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, soustraction
	mov edx, len_sous
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, division
	mov edx, len_div
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, multiplier
	mov edx, len_multi
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, choix
	mov edx, len_choix
	int 0x80
 
saisie:
	mov eax, 3
	mov ebx, 1
	mov ecx, operation
	mov edx, 2
	int 0x80
 
comparaison:
	mov al, [operation]
	cmp al, "1"
	je op_add
 
	mov al, [operation]
	cmp al, "2"
	je op_sous
 
	mov al, [operation]
	cmp al, "3"
	je op_div
 
	mov al, [operation]
	cmp al, "4"
	je op_multi
	jmp fin
 
op_add:
	mov eax, 4
	mov ebx, 1
	mov ecx, choix_add
	mov edx, len_choix_add
	int 0x80
 
	mov eax, 10
	add eax, 15
 
	mov bl, 10
	div bl
 
	add al, 0x30
	mov [nbre1], al
 
	mov al, ah
	add al, 0x30
 
	mov [nbre2], al
 
	mov eax, 4
	mov ebx, 1
	mov ecx, result
	mov edx, len_result
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, nbre1
	mov edx, 1
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, nbre2
	mov edx, 1
	int 0x80
 
	jmp fin
 
 
 
op_sous:
	mov eax, 4
	mov ebx, 1
	mov ecx, choix_sous
	mov edx, len_choix_sous
	int 0x80
 
	mov eax, 5
	sub eax, 2
 
	mov bl, 1
	div bl
 
	add al, 0x30
	mov [nbre1], al
 
	mov eax, 4
	mov ebx, 1
	mov ecx, result
	mov edx, len_result
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, nbre1
	mov edx, 2
	int 0x80
 
 
	jmp fin
 
op_div :
	mov eax, 4
	mov ebx, 1
	mov ecx, choix_div
	mov rdx, len_choix_div
	int 0x80
 
	mov eax, 27
	mov bl, 9
	div bl
 
	mov bl, 1
	div bl
 
	add al, 0x30
	mov [nbre1], al
 
	mov eax, 4
	mov ebx, 1
	mov ecx, result
	mov edx, len_result
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, nbre1
	mov edx, 2
	int 0x80
 
	jmp fin
 
op_multi:
	mov eax, 4
	mov ebx, 1
	mov ecx, choix_multi
	mov edx, len_choix_multi
	int 0x80
 
	mov eax, 3
	mov bl, 2
	mul bl 
 
	mov bl, 1
	div bl
 
	add al, 0x30
	mov [nbre1], al
 
	mov eax, 4
	mov ebx, 1
	mov ecx, result
	mov edx, len_result
	int 0x80
 
	mov eax, 4
	mov ebx, 1
	mov ecx, nbre1
	mov edx, 2
	int 0x80
 
	jmp fin
 
fin:
	mov eax, 1
	mov ebx, 0
	int 0x80

Pour compiler :

nasm -f elf nom_du_fichier.asm -o nom_du_fichier.o
ld -m elf_i386 nom_du_fichier.o -o nom_du_fichier

Bien a vous.

-
Edité par Code Rom il y a environ 1 heure