Discussion :

[geek-59600]

Bonsoir à tous, dans le but d'essayer de mieux comprendre le fonctionnement "profond" du pc j'ai voulu me pencher sur l'assembleur.

Aprés avoir lu pas mal de chose la dessus je me suis penché sur un premier programme basique un simple hello world qui a fonctionné ( pas tout de suite mais j'ai fini par réussir ) mais en voulant compliqué la chose ca ne veux plus

Je suis sous Ubuntu 10.04 j'utilise gedit nasm et gcc

voici mon 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
 
 
BITS 32                                   ; <- je ne sais pas a quoi ca sert :/
 
SECTION .data                          ; <- début des donnée "initialisée"
 
toto db "toto",13,10,0                 ; <- une simple chaine de caractéres
taille equ $-toto                         ; <- affecte à taille la longeur de toto bien que je ne comprends pas exactement comment
 
SECTION .text                           ; <- début du code
 
GLOBAL main
main:
 
mov eax,4                                ; <- préparation du syscall 4 pour écrire à l'écran
mov ebx,1
mov ecx,toto
mov edx,taille
int 0x80
 
mov eax,20                               ; <- syscall 20 : getpid
mov ebx,0
int 0x80
 
mov ecx,eax                             ; <- stockage de la valeur de retour du getpid dans ecx en vue d'un affichage
mov eax,4
mov ebx,1
mov edx,5                              ; <- valeur mise un peu au hasard en me basant sur la taille des pid dans /proc
int 0x80
 
mov eax,1                              ; <- préparation de l'extinction du programme
mov ebx,0
int 0x80

C'est surement loin d'être parfait mais c'est mon premier test en asm.

Comme vous avez pu le lire il y a encore beaucoup de chose que je ne comprends pas et que j'aimerai que vous m'expliquiez :

A quoi corresponds BITS 32 ?

Code :

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

taille equ $-toto

comment l'expression est elle évalué ? que représente le '$' ?

Il y a t il moyen de connaitre la valeur de 'taille' j'ai essayé de mettre taille dans ECX avec un EBX de 1, 2, 3, 4 mais jamais obtenu de résultat .

De même la tentative d'obtention du PID est sans résultat :/ ; il y a t il moyen de savoir la taille des données contenue dans ECX a savoir le PID afin de le stocker dans EDX

Et enfin, j'ai lu que l'on mettait les arguments dans les différent registres avant l'appel d'une fonction mais comment faire quand on a 10 arguments je n'ai pas de fonction de ce genre mais c'est simplement par curiosité .

Voici un lien que j'ai trouvé avec quelques syscalls : http://asm.sourceforge.net/syscall.html le reste étant disponible ( sous ubuntu 32b ) dans /usr/include/asm/unistd32.h et les pages man .

Merci d'avance, bonne soirée

[orfix]

A quoi corresponds BITS 32 ?

Cela indique à ton assembleur que ton code doit être assemblé pour une architecture 32-bit (taille des registres, bus d'adresses, ...)

comment l'expression est elle évalué ? que représente le '$' ?

le $ est remplacé par l'adresse mémoire du début de la ligne, je te laisse deviner ce que fait $-toto.

Code :

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

1
2
3
4
5
6
toto                          $
  |                           |
  v                           v
+---+---+---+---+---+---+---+---+---+
| t | o | t | o | 13| 10| 0 | ? | ? | ...
+---+---+---+---+---+---+---+---+---+

Code :

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

1
2
3
4
5
6
7
8
9
mov eax,20                               ; <- syscall 20 : getpid
mov ebx,0
int 0x80
 
mov ecx,eax                             ; <- stockage de la valeur de retour du getpid dans ecx en vue d'un affichage
mov eax,4
mov ebx,1
mov edx,5                              ; <- valeur mise un peu au hasard en me basant sur la taille des pid dans /proc
int 0x80

getpid() ne prend aucun argument, de plus si tu veux afficher des entiers, tu devras te débrouiller pour écrire ta propre routine, sujet déjà débattu sur ce forum à plusieurs reprises, sinon tu peux faire appel à libc (printf et compagnie)

Et enfin, j'ai lu que l'on mettait les arguments dans les différent registres avant l'appel d'une fonction mais comment faire quand on a 10 arguments je n'ai pas de fonction de ce genre mais c'est simplement par curiosité .

Tu devras les faire passer via la pile.

[geek-59600]

Merci bien, je comprends mieux

Donc le syscall 4 à savoir write ne permet pas d'écrire d'entier ? Pourriez vous me dire ce qu'admet le syscall 4 de facon 'native' sans faire de routine annexe et sans faire intervenir la libc ?

Quand vous dite que getpid() ne prend aucune paramètre vous faites allusion au mov EBX,0 qui devient superflu donc ?

Merci encore.

Bonne soirée

[orfix]

Donc le syscall 4 à savoir write ne permet pas d'écrire d'entier ?

Je n'ai pas dit cela, write permet de tout écrire, quant-on écrit sur la sortie standard stdin (descripteur 1), généralement c'est l'écran il est donc impératif d'envoyer à write des chaînes de caractères: une suite de code ASCII (cela dépend de l'encodage, l'ASCII est toutefois prédominant), donc ta valeur entière disant 12345 par exemple devras être convertis en "12345", je te laisse faire une petite recherche sur ce forum, encore mieux essayes de le faire par tes propres moyens, si tu débutes en assembleur, ceci est un très bon exercice

Essaies dans un premier temps d'afficher des chiffres, puis des nombres non signés et enfin des nombres signés.
Un indice pour obtenir le code ASCII d'un chiffre x, tu fais x+'0' .

Pourriez vous me dire ce qu'admet le syscall 4 de facon 'native' sans faire de routine annexe et sans faire intervenir la libc ?

Code man 2 write :

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

1
2
3
4
5
6
7
8
 
SYNOPSIS
       #include <unistd.h>
 
       ssize_t write(int fd, const void *buf, size_t count);
 
DESCRIPTION
       write() writes up to count bytes from the buffer pointed buf to the file referred to by the file descriptor fd.

Quand vous dite que getpid() ne prend aucune paramètre vous faites allusion au mov EBX,0 qui devient superflu donc ?

Exact


Bon courage.

[geek-59600]

J'ai compris le truc enfin j'imagine, on décompose le nombre par succession de modulo de 10 et pour chaque chiffre on ajoute 48, cependant il faut le réorganiser car les caractères sont dans le mauvais sens.

Bon j'vais aller potasser un peu la mémoire en assembleur quand je dis que je débute c'est vraiment débuter je suis dessus depuis 14H aujourd'hui

Merci beaucoup

[geek-59600]

Bonjour,

j'ai essayé de me familiariser un peu avec toutes ses nouvelles notions j'ai donc pondu ce petit code qui devait me permettre de connaitre le nombre de chiffre dans un nombre

J'ai voulu procéder par succession de modulo de 10 .

Voici mon code qui foire

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
 
BITS 32
 
SECTION .bss
 
temp resd 4
 
SECTION .data
 
L2 db 11  
 
SECTION .text
 
GLOBAL main
 
main:
 
mov eax,0
mov ebx,0
mov ecx,0
mov edx,0
mov eax,[L2]
mov ecx,10
 
boucle:
div ecx
inc ebx
cmp eax,0
je finboucle
jmp boucle
 
finboucle:
 
;placer le compteur en 1 er char
 
add ebx,48
mov [temp],ebx
 
;ajout d'un éspace
 
mov ebx,32
mov [temp+1],ebx
 
;ajout d'un retour a la ligne
 
mov eax,10
mov [temp+2],eax
 
;appel de write
mov eax,4
mov ebx,1
mov ecx,temp
mov edx,3
 
int 0x80
 
;on quite
mov eax,1
mov ebx,1
 
int 0X80

Cependant je rentre en boucle infini car EAX prend une valeur étrange :

Aprés l'initialisation EAX = 11 ; EBX = 0 ; ECX = 10 ; EDX = 0

Aprés la premiére division EAX = 1 ; EBX = 1 ; ECX = 10 ; EDX = 1

Sachant de EAX != 0 on refait une boucle

Le problème ce trouve la, après la 2 eme division

EAX = 429496729 ; EBX = 2 ; ECX = 10 ; EDX = 7

Donc vous imaginez bien que ca part en boucle infinie ...

Pourriez vous m'expliquer quelle est la raison de cette valeur ?

Merci d'avance

Bonne journée

[orfix]

Pourriez vous m'expliquer quelle est la raison de cette valeur ?

Il faut comprendre comment fonctionne l'instruction DIV en 32-bit:

Code :

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

1
2
3
DIV op      ; EDX:EAX / op
            ; EAX = le quotient
            ; EDX = le reste

il faut donc faire très attention tu ne divises pas EAX mais EDX:EAX, pour corriger ton code il suffit de déplacer le mov edx, 0 comme suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
<...>
;mov eax,0          inutile, tu l'écrases juste après
mov ebx,0
;mov ecx,0          inutile, tu l'écrases juste après
;mov edx,0          à déplacer ...
mov eax,[L2]
mov ecx,10

boucle:
mov edx,0           ;... ICI
div ecx
<...>

Un programme qui se termine normalement retourne 0 :

Code :

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

1
2
3
4
5
;on quite
mov eax,1
mov ebx,0

int 0X80

Bon courage.

[geek-59600]

Merci bien, effectivement ca fonctionne

Pourriez vous cependant m'expliquer ce que signifie la notation EDX:EAX j'ai lu de nombreuse fois une histoire de bit de poid fort / faible sans réellement trouvé une définition qui m'explique clairement la chose, suis je dans le bon ou complètement à l'ouest ?

Merci encore

[orfix]

Dans ce contexte c'étais juste pour indiquer que tu divisais un nombre de 64 bits, où EDX représentais la partie de poids le plus fort, tandis que EAX celle de poids le plus faible.

Code :

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

1
2
3
4
5
MOV EDX, 0xAAAA
MOV EAX, 0xBBBB
MOV EBX, 0xCCCC
DIV ECX             ; EAX = 0xAAAABBBB / 0xCCCC
                    ; EDX = 0xAAAABBBB % 0xCCCC

[geek-59600]

Donc dans mon erreur précédente la seconde div était 10001 / 10 c'est ca ?

Je comprends mieux merchi

[orfix]

Plus quelque chose comme :

Code :

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

1
2
3
4
5
6
7
            EDX         EAX             EDX:EAX (en decimal)
cycle 1     0x00000000  0x0000000B      11
cycle 2     0x00000001  0x00000001      4294967297
cycle 3     0x00000007  0x19999999      30494267801
cycle 4     0x00000001  0xB5C28F5C      7344394076
...
<vers l'infini et au-delà>

En initialisant EDX à zéro après chaque division on obtient :

Code :

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

1
2
3
4
5
6
            EDX         EAX             EDX:EAX (en decimal)
cycle 1     0x00000000  0x0000000B      11
cycle 2     0x00000000  0x00000001      1
cycle 3     0x00000000  0x00000000      0
 
<on sort de la boucle>

Faire la trace de son programme (à la main) et aussi un bon exercice

[geek-59600]

Merci bien, j'avais fais la trace via GDB c'est la que j'ai compris qu'il y avait probléme car EAX me donnait des valeurs énormes, merci aussi pour l'explication EDX:EAX vu comme ca je comprends mieux

Ca fait toujours plaisir de constater que certaine personne accepte encore de partager leur savoir

Bonne journée

[orfix]

De rien, n'oublies pas le

[geek-59600]

J'ai passé le message en résolu mais j'ai encore une petite question.

Quand on fait un DIV on divise donc EDX:EAX / ECX ; EDX:EAX peut donc nous fournir un nombre de 64bit c'est ca ? mais qu'en est il si ont veut diviser car un nombre trés grand ECX ne faisant que 32 bit ?

Exemple trés bête mais bon je suis curieux imaginons que je souhaite diviser 0xFFFFFFFFFFFFFFFF par lui même ( j'avais prévenu c'est vraiment un exemple bête )

je fais donc

mov EDX, FFFFFFFFh
mov EAX, FFFFFFFFh

et

mov ECX, FFFFFFFFFFFFFFFFh sauf que la ca va forcément coincé vu qu'on overflow le registre si je dis pas de bêtise

Le nombre à diviser est stocker dans une paire de registre, mais le diviseur à un registre unique donc comment faire ?

Merci encore et désolé pour toutes ces questions de débutants

Bonne soirée

[orfix]

Quand on fait un DIV on divise donc EDX:EAX / ECX ;...

Non, la taille du quotient est déterminée par l'opérande de DIV (qui peut ne pas être ECX) si :

• c'est un nombre sur 8-bits la dividende doit être sur 16-bits
• c'est un nombre sur 16-bits la dividende doit être sur 32-bits
• c'est un nombre sur 32-bits la dividende doit être sur 64-bits

C'est ainsi, je suis incapable de t'expliquer la logique derrière tout cela, mais il y en a sûrement une.

Exemple trés bête mais bon je suis curieux imaginons que je souhaite diviser 0xFFFFFFFFFFFFFFFF par lui même ( j'avais prévenu c'est vraiment un exemple bête )

je fais donc

mov EDX, FFFFFFFFh
mov EAX, FFFFFFFFh

et

mov ECX, FFFFFFFFFFFFFFFFh sauf que la ca va forcément coincé vu qu'on overflow le registre si je dis pas de bêtise

Le nombre à diviser est stocker dans une paire de registre, mais le diviseur à un registre unique donc comment faire ?

Franchement je ne sais pas.

Merci encore et désolé pour toutes ces questions de débutants

Il n'y a pas de souci, toutefois je te conseil d'ouvrir un livre d'assembleur, ou chercher sur le net un bon cours la dessus.

[geek-59600]

J'ai parlé a un prof de DUT Info, il ne connais pas de bouquin sur l'ASM sur linux connaissez vous une référence ?

[orfix]

Non désolé mais tu pourrais peut-être ouvrir une autre discussion et y poser ta question, bonne chance.