Discussion :

[chrtophe]

J'ai pas été assez précis dans ma seconde question, je vais la reformuler :
Pour afficher n'importe quel contenu de eax converti en chaine ASCII, combien dois-je réserver de cases mémoires ?
Pour la première question (simple) la réponse est bonne.

j'ai réussis a afficher mes 3 chiffres, mais dans le sens inverse

Oui, pour moi, c'était attendu.

Donc maintenant,
1 : pourquoi ?
2 : comment résoudre ce problème ?

Essayes d'au moins répondre à la question pourquoi.
Indice : corriger d'abord le code (qui est bon pour ce cas précis et tout cas ou eax<=999) pour être capable de fonctionner sans mettre 3 dans edx
mais en le calculant, ce qui te permettra d'avoir un code de conversion ASCII et d'affichage pour toute valeur 32 bits.

[Code Rom]

Alors pour la première question je dirais une seule case mémoire , car "le codage" ASCII va de 0 a 127 on peut donc coder n'importe quel chiffre de celui ci sur un systeme 32 bits, une case mémoire de 32 bits suffira.

Ensuite pourquoi j'arrive a afficher le chiffre mais dans le sens inverse selon moi c'est pour ça :

En fait je commence par diviser 732 par 10 ce qui fait 73,2 puis je place le reste donc 2 dans edx.Je lui ajoute 0x30.Puis ça boucle, donc division de 73,2 par 10 = 7,32 pareil ajout du reste donc 32 dans edx et ainsi de suite, au final j'ai ajouté dans edx dans l'ordre 2, 3, 7, et c'est se que j'affiche.Voila pourquoi le chiffre est a l'inverse.

Indice : corriger d'abord le code (qui est bon pour ce cas précis et tout cas ou eax<=999) pour être capable de fonctionner sans mettre 3 dans edx
mais en le calculant, ce qui te permettra d'avoir un code de conversion ASCII et d'affichage pour toute valeur 32 bits.

Là je sèche...... je ne comprend pas, calculer quoi pour ne pas mettre 3 dans edx ? il faut calculer la longeur alloué au buffer qui contient le chiffre, donc une sorte de fonction strlen, c'est ça ? je ne sais pas vraiment.

[chrtophe]

Alors pour la première question je dirais une seule case mémoire , car "le codage" ASCII va de 0 a 127 on peut donc coder n'importe quel chiffre de celui ci sur un systeme 32 bits, une case mémoire de 32 bits suffira.

Non, la valeur maximale de eax peut être 0xffffffff soit 4294967295 c'est à dire un peut plus de 4 milliards occupant 10 caractères ASCII. Donc si tu réserves 10 caractères, tu pourras stocker en ASCII n'importe quelle valeur contenue dans eax.

Tu as bien compris pourquoi le résultat est inversé. On fait le traitement de droite à gauche alors qu'on écrit de gauche à droite. Je vais t'apprendre une nouvelle fonction : rep movsb

rep movsb est constitué de deux fonctions rep et movsb. rep va répéter la fonction autant de fois que la valeur de ecx. (rep est utilisable avec certains mnémoniques) movsb recopie le caractère dans la case mémoire de l'adresse esi dans la case mémoire de l'adresse d'edi (en fait le couple ds: es:edi il faut donc que les registres de segment ds et es soient égaux)
Nous aurons donc besoin d'un deuxième espace réservé pour la nouvelle chaine.

Nous connaissons l'adresse de fin de la chaine (contenue dans esi après la fin de la boucle), nous connaissons son, début (total), nous pouvons donc facilement calculer sa longueur et exécuter rep movsb.

Essayes de faire le code.

Je te donnerais ensuite quelques autres informations.

[Code Rom]

Bon voila plus d'une heure que je planche sur le sujet, j'ai beaucoup de mal.J'ai peur que le code ne soit pas correct car j'ai ajouté seulement 2 lignes : sub edi, esi et rep movsb.J'ai beau me tordre la tête il me semble que ma logique est bonne a savoir que pour calculer la longeur on soustrait l'arrivée moins le départ, ici l'adresse de fin donc la valeur de esi après la boucle et le début qui est la valeur de total en début de programme.Voila pourquoi j'ai ajouté la ligne : sub edi, esi.esi contient l'adresse de fin edi contient total du début de programme (cf la 2ème ligne : mov edi, total).

J'ai essayé en vain d'afficher cette fameuse longueur stocké dans edi, je n'y suis pas arrivé.

Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
segment .text
 
global _start
 
_start:
 
	mov eax, 732		; eax vaut 732 = aussi le numérateur															
 
	mov edi, total 	; Avant la boucle stocker dans edi l’adresse de ta variable qui stockera la chaine ASCII.				
 
	mov ebx, 10			; ebx est le dénominateur.
 
	operation :																																					
 
 
	div ebx				; on divise eax par 10
 
	add edx, 0x30		; on ajoute a edx (qui contient le reste) 0x30 pour la convertion ASCII
 
	xchg eax, edx		; échanger eax et edx
 
	stosb 				; stocker le contenu de al dans la variable avec stosb
 
	mov eax, edx		; mettre le contenu de edx dans eax 
 
	xor edx, edx		; mettre edx à 0
 
	cmp eax, 10			; on compare eax a 10, eax > 10 ?
 
	jge operation 		; saut conditionnel jump if greater equal, saut a l'étiquette operation si eax > 10
 
	add eax, 0x30		; on ajoute a ecx 30h pour la convertion ASCII
 
	stosb
 
	sub edi, esi 		; on soustrait esi qui contient la fin de la chaine a edi qui contient total  soit le début de la chaine
						; on a donc a la fin la longeur de la chaine dans edi
 
	rep movsb
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, total
	mov edx, 3
	int 0x80
 
	xor eax, eax
 
	;Fin du programme
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
segment .bss
 
total 		resb 	3
total2		resb 	3

Voila j'ai fait ce que je pouvais mais l'assembleur reste encore flou dans ma tête, je suis loin de maitriser quoique ce soit.

[chrtophe]

Le rep movsb ne peut pas fonctionner car il va copier la chaine 1 dans la chaine2 dans le même ordre, alors que nous, nous voulons copier le dernier caractère de la chaine 1 dans le 1er de la chaine 2 l'avant dernier dans le second etc..

A la fin de notre boucle, edi contient l'adresse du dernier caractère généré +1 (car edi a été incrémenté après copie du dernier caractère).
Nous avons besoin de faire une boucle correspondant au nombre de caractère à copier, cette boucle devra copier les caractères en orde inverse.

Commençons par calculer le nombre de caractères que nous allons placer dans ecx, ecx car nous pourrons utilser des sauts conditionnels testant ecx.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
mov ecx,edi # ecx=position dernier caractère +1
sub ecx,total
dec ecx # dec =décrémente décrementer revient à faire -1 ecx est donc égal à adresse début chaine - adresse fin chaine = longueur chaine

les opcodes comme lodsb, stosb, movsb incrémentent le registre d'adresse utilisé après avoir fait l'opération. Il y a un flag dans le CPU pour décrémenter plutôt qu'incrémenter, le flag DF(Direction flag). Mais dans ce cas nous ne pouvons pas l'utiliser car les sens de lecture de la chaine source et d'écriture de la chaine destination sont inversés.

Il nous faut donc faire une boucle qui va charger le dernier caractère, là je vais te donner le code car tu ne t'en sortiras pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
mov edi,total2
boucle:
mov al,[esi+ecx] #va charger le caractère dans l'adresse esi+la valeur de ecx
stosb
dec ecx
jcxnz boucle # saute à boucle si ecx n'est pas égal à zéro

Pour la partie affichage il faut ensuite positionner edx à la longueur de la chaine pour l'afficher, indice on a déjà la valeur, il ne faut pas la recalculer mais la conserver : comment faire ?

[Code Rom]

Je suis désolé mais je n'arrive plus a suivre là.J'ai beau lire et relire la question je n'ai pas le moindre début d'idée de la réponse.Je débute trop en asm je ne sais comment faire pour "positionner edx à la longueur de la chaine pour l'afficher".Il me semble avoir compris que la longueur de la chaine est stocké dans ecx, j'ai compris que l'on devait ajouter 0x30 a une variable pour la convertir en ascii, je sais que pour afficher une variable il fait faire ces deux syscall eax, 4 suivit de ebx, 1 puis int 0x80.J'ai compris l'instruction mov, add,div, inc, dec et je sais faire a peu prêt une boucle avec saut conditionnel.

Sortie de ça je ne sais pas faire plus de chose pour le moment en assembleur.J'essaye de suivre mais là ça me dépasse.j'espère ne pas te decevoir j'essaye d'être le plus honnête avec toi et j'essaye vraiment de répondre aux questions quand je le peux.Là dans le cas present je n'y arrive pas.

[Kannagi]

Tout dépend aussi de ton niveau en programmation , arriverais-tu a le faire en pseudo-code ?

Si ton soucis est purement algorithmique alors avec le temps tu y arrivera , les mov ,add ,sub , cmp , jne ne sont que des "équivalents" des var = a +b; et des if/else/for/while

[chrtophe]

la fonction write (eax=4 int 0x80) attend la longueur à afficher dans le registre edx.

la longueur de la chaine, nous l'avions déjà calculé avec ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 mov ecx,edi # ecx=position dernier caractère +1
sub ecx,total
dec ecx # dec =décrémente décrementer revient à faire -1 ecx est donc égal à adresse début chaine - adresse fin chaine = longueur chaine

Mais ecx sera ensuite modifié à chaque boucle. De façon à ne pas devoir recalculer cette valeur il faut sauvegarder le contenu de ecx pour l'exploiter avec la fonction write

2 solutions : copier la valeur dans un registre non utilisé, comme ebx par exemple, et copier le contenu de ebx dans dex au moment opportun, soit sauvegarder sur la pile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
push ecx
...
...
...
pop edx

[Code Rom]

Je ne sais pas si j'arriverais a le faire en pseudo code, je vais essayer, je vais aussi continuer le code déjà commencer ici afin d'afficher correctement le nombre 732, je posterais le code ici.
J'aurais etait incapable de répondre a la dernière question beaucoup trop de subtilité m'échappent encore.Il faut que je me documente correctement sur ce qu'est la pile par exemple et comment manipuler tout cela.Mon problème est algorithmique mais aussi théorique il ya des bases que je n'ai pas encore.J'ai un certain nombre de liens et de documents qui vont m'aider dans ce sens.

Enfin , encore une fois merci a chrtophe d'avoir pris le temps de m'expliquer tout cela mais je partais de trop bas pour pouvoir suivre correctement.J'ai quand même appris beaucoup de choses (boucles, l'ajout de 0x30, les intructions add, mov, inc,dec,div,stobs comment reserver n bytes dans le segment .bss et surtout la signification de ces lignes, j'ai progressé niveau syntax et comprehension de l'assembleur, je comprends mieux les registres surtout les 32 bits, je sais faire un saut conditionel) ça fait déjà pas mal de choses par rappport au niveau zéro que j'avais avant ce sujet.C'est vraiment très sincèrement que je le remercie.

Je vais continuer mon apprenitissage de l'assembleur et bien sur en cas de blocage je poserais mes questions sur le forum.

Tchaooo.

[chrtophe]

Il faut que je me documente correctement sur ce qu'est la pile par exemple

C'est pourquoi j'ai proposé l’alternative d'utiliser ebx comme stockage de la longueur de chaine.

[Code Rom]

Bon si tu es d'accord on peut essayer de recommencer cet apprentissage et ce but de faire cette fameuse addition et d'afficher le resulat, moi je suis partant.Mais n'oublie pas que je débute et que j'ai des lacunes théorique, je ferrais de mon mieux ça je te l'assure.

A toi de décider.

[chrtophe]

Je pense que tu as toutes les briques.

refais le code bloc par bloc.

Faire la division, je pense que c'est bon pour toi.


Refais le code permettant de convertir n'importe quelle valeur de eax en chaine de caractères, en gardant la longueur de la chaine dans ebx par exemple.
Je pense que tu devrais t'en sortir.

[Code Rom]

Salut, juste un petit message pour vous dire que je lache pas l'affaire la preuve.

1) j'ai réussis a faire une addition est a afficher le résultat , on peut changer les nombres en debut de code le resultat affiché reste correct :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
segment .text
 
global _start
 
_start :
 
		xor eax, eax
		mov eax, 5
		add eax, 4
 
		;calcul nbre1
		mov bl, 10
		div bl
 
		add al, 0x30
		mov [nbre1], al
 
		; calcul nbre2
		mov bl, 1
 
		mov al, ah
		xor ah, ah
		div bl
 
		add al, 0x30
		mov [nbre2], al
 
		;affichage nbre1
		mov eax, 4
		mov ebx, 1
 
		mov ecx, nbre1 
		mov edx, 1
		int 0x80
 
		;affichage nbre2 
		mov eax, 4
		mov ebx, 1
 
		mov ecx, nbre2 
		mov edx, 1
		int 0x80
 
		;fin program
		mov eax, 1
		mov ebx, 0
 
		int 0x80 
 
 
segment .bss
 
nbre1 	resb 	1
nbre2	resb	1
total	resb 	2

et j'ai réussis aussi a afficher le chiffre 732 codé en dur , bon là je me suis aidé d'une correction d'exercice donc un peu moins de "panache"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
segment .text
 
global _start
 
_start :
 
	xor eax, eax
	mov eax, 732
 	mov bl, 100
    div bl
 
    add al , 30h
 
    mov [chiffre1], al
 
    mov bl, 10
 
    mov al, ah
    xor ah, ah
    div bl
 
    add al, 30h
    mov [chiffre2], al
 
    add ah, 30h
    mov [chiffre3], ah
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, chiffre1
	mov edx, 1
	int 80h
 
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, chiffre2
	mov edx, 1
	int 80h
 
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, chiffre3
	mov edx, 1
	int 80h
 
 
	;fin
	mov eax, 1
	mov ebx, 0
 
	int 80h
 
 
segment .bss
 
chiffre1:	resb	1
chiffre2: 	resb	1
chiffre3:	resb	1

Voila, bien a vous.

[chrtophe]

Je n'ai pas testé mais si tu t'en es sorti, c'est très bien.

Je vais te donner une autre petite leçon. Faire une division pour un cpu est une opération très couteuse qu'on essayes d'éviter.

L'arithmétique binaire a une propriété intéressante :

diviser une valeur est la même chose que de faire un décalage de 1 bit vers la droite, divisier par 4, de 2 bits, etc. Et en décalant vers la gauche, on multiplie.

Donc s i on doit diviser une valeur par un multiple de 2, on va faire un décalage de bits. Par contre si il y un reste, tu le perd. Il est donc possible de faire un code plus efficace que celui que l'on a fait, mais plus dur aussi. Pour notre exemple ça n'a pas d'intérêt.
Les CPU ARM par exemple n'ont pas d'opcode de division.
Note la notion de décalage, c'est très utilisé en assembleur.

[Code Rom]

Salut chrtophe merci pour cette petite leçon supplémentaire je vais essayer de refaire l'addition mais avec le décalage de bits.

Pour le moment je met le sujet comme resolu car le but était de faire une addition et d'en afficher le resultat, c'est désormais fait.

Merci pour tout tes conseils precieux, a +++

[Code Rom]

Bonjour,

après un petite pause avec l'assembleur, je me suis dis que j'allais avoir quelques problèmes avec cette histoire de décalage a gauche / droite.Puis en fait absolument pas.J'ai réussis rapidement a faire une mutliplication donc décalage à gauche avec l'instruction SHL.

Voici le code.Il suffit de modifier la ligne shl, 1 par, exple shl, 2 pour faire des multipication d'entier positif (c'est ça hein ? un entier par définition n'a pas de reste, car avec ce code le reste est perdu, donc uniquement mutiplier des mutliples de 2, chrtophe l'avais précisé juste au dessus).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
segment .text
global _start
 
_start :
 
	xor eax, eax 
	xor ebx, ebx 
	xor ecx, ecx 
	xor edx, edx
 
	mov eax, 5
	;mov ebx, 2
 
	shl eax, 1
 
	;calcul nbre1
	mov bl, 10
	div bl
 
	add al, 0x30
	mov [nbre1], al
 
	;calcule nbre2
	mov bl, 1
 
	mov al, ah
	xor ah, ah
	div bl
 
	add al, 0x30
	mov [nbre2], al
 
 
	;affichage nbre1
	mov eax, 4
	mov ebx, 1
 
	mov ecx, nbre1 
	mov edx, 1
	int 0x80
 
 
	;affichage nbre2
 
	mov eax, 4
	mov ebx, 1
 
 
	mov ecx, nbre2
	mov edx, 1
	int 0x80
 
	;fin de programm
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
segment .bss
nbre1	resb	1
nbre2	resb	1

Je pense que les opérations basique (addtition , soustraction , multiplication division et modulo) je commence a prendre le coup.Je vais refaire un programme qui récapitule le tout, une sorte de calculatrice avec demande de saisie de l'utilisateur ça je ne sais pas encore faire, et puis un petit menu sympa, bref un truc simple mais récapitulatif, ça devrais bien encrer les choses dans ma caboche ^^.

Bonne journée, tchoooo !