Discussion :

[Roud9]

Bonjour,

Je veux afficher le contenu d'un fichier dont le nom a été entré par l'utilisateur, mais je dois entrer le nom du fichier lorsque je lance le programme (ex: ./monprogramme test.asm). J'aimerais ne pas avoir à spécifier le nom du fichier à chaque exécution, mais que ce soit à l'utilisateur de le faire lorsqu'il est invité à entrer le nom. Je précise que la lecture et l'affichage fonctionnement correctement. Voilà ce que j'ai fait jusqu'à maintenant :

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
 
segment .data 
nom_fichier : db "Entrez le nom du fichier : ", 10
nom_fichier_len equ $-nom_fichier
 bufsize dw      1024
 
segment .bss
fichier        resb 32
 buf     resb    1024
;; Message qui demande à l'utilisateur d'entrer un nom de fichier
	mov eax, 4
	mov ebx, 1
	mov ecx, nom_fichier
	mov edx, nom_fichier_len
	int 0x80
 
	;; Lecture nom du fichier
	mov eax, 3
	mov ebx, 0
	mov ecx, fichier
	mov edx, 32
	int 0x80
 
  ; get the filename in ebx
	pop   ebx
    pop   ebx               
    pop   ebx              
    pop   ebx    
 
  ; ouvrir le fichier
    mov   eax,  5           ; ouverture
    mov   ecx,  0           ;   lecture seulement
    int   80h               
  ; lire le fichier
    mov     eax,  3         ; lecture
    mov     ebx,  eax       ;   descripteur
    mov     ecx,  buf       ;   *buf,
    mov     edx,  bufsize   ;   *bufsize
    int     80h             
 
  ; afficher le contenu à l'écran
    mov     eax,  4         ; affiche à l'écran
    mov     ebx,  1         
    int     80h

Merci de votre aide

[supersnail]

Bonjour,

En gros, tu veux récupérer les arguments passés en ligne de commande, c'est ça?

Ben ça marche comme pour n'importe quelle fonction, tes arguments sont situés sur la pile

[edfed]

la ligne de commande est passée dans un buffer.

ce buffer est localisé à l'offset 81h
l'octet 80h contient la taille du buffer.

le premier octet du buffer est souvent egal à ' ' (espace), et ne permet donc pas l'utilisation directe avec les fonctions fichiers dos, il faut d'abord trouver le premier caractère affichable à partir de 81h, et de là, on à le nom du fichier passé en ligne de commande.

une autre solution serait aussi d'avoir un nom de fichier predefini, et si la ligne de commande contient un nom, alors il sera pris, et si l'utilisateur entre un nom de fichier, il sera pris lui aussi.

à terme, il faut aussi pouvoir manipuler des pointeurs vers nom de fichier plutot que directement les noms de fichiers. c'est plus rapide et efficace.

[supersnail]

Bonjour,

Sauf que là le monsieur développe sous Linux (cf l'int 80h).
Donc, pour le DOS, ça fonctionnera pas trop ici

[edfed]

il doit bien y avoir l'equivalent du psp sous linux, du type,

mov eax,X
int 80h..

X étant les paramètres de la ligne de commande.

[golden boy]

Si on part du principe que main() est une fonction qui prend deux arguments (argc et argv) je crois, sans en être sûr (souvenir lointain), que argc est stocké sur la pile à [esp+4] et que argv est stocké à [esp+8].

J'ai regardé vite fais avec gdb si c'était cohérent, mais sans tester, donc je ne garantis pas que c'est ok. Je pense que ça doit marcher aussi bien sur Linux que sur NT ou même un autre OS.

[Obsidian]

Si on part du principe que main() est une fonction qui prend deux arguments (argc et argv) je crois, sans en être sûr (souvenir lointain), que argc est stocké sur la pile à [esp+4] et que argv est stocké à [esp+8].

Ça dépend de plusieurs choses, notamment de ton architecture (les chiffres sont différents si tu travailles en 64 bits) et de certains détails de compilation (les noyaux Linux récents permettent dans certaines conditions de stocker autant d'arguments que possible dans les registres du processeur).

Mais d'une manière générale, il vaut mieux s'appuyer sur EBP plutôt qu'ESP.

[orfix]

J'ai regardé vite fais avec gdb si c'était cohérent, mais sans tester, donc je ne garantis pas que c'est ok. Je pense que ça doit marcher aussi bien sur Linux que sur NT ou même un autre OS.

Je ne pense pas que se soit le cas sous Windows par exemple... sinon je confirme pour Linux argc et argv[] se trouvent sur la pile:

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
+---------+
| argc    | <- ESP
+---------+
| argv[0] |
+---------+
| ...     |
+---------+
| argv[n] |
+---------+
| NULL    |
+---------+
| env[0]  |
+---------+
| ...     |
+---------+
| env[n]  |
+---------+
| NULL    |
+---------+

(Cela fait bien longtemps que je n'ai pas touché à l'assembleur, j'ai un peux perdu mes réflexes )

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
BITS 32
 
SECTION .data
	nl: 		db 10
	sys_write: 	equ 4
	sys_exit: 	equ 1
 
SECTION .text
	global _start
 
_start :
	pop ecx			; argc
	pop ecx			; argv[0] program name
 
.parse:
	mov eax, sys_write
	mov ebx, 1
	call strlen
	int 80h
 
	mov eax, sys_write
	mov ecx, nl		; new line
	mov edx, 1
	int 80h
 
	pop ecx			; next argument
	test ecx, ecx
	jnz .parse
 
.done :
	mov eax, sys_exit
	mov ebx, 0		; EXIT_SUCCESSFUL
	int 80h	
 
strlen:
	push eax
	mov edx, ecx
 
.nextbyte:
	mov al, [edx]
	test al, al
	jz .nullbyte
	inc edx
	jmp .nextbyte
 
.nullbyte:
	sub edx, ecx
	pop eax
	ret

[golden boy]

En effet, j'aurais dû penser à le préciser : mon décalage dans la pile de 4 et de 8 ne fonctionne qu'en 32 bits.
En 64 bits, je suppose qu'on a du [rsp+8] et [rsp+16], mais je n'ai pas de 64 bits, je ne peux pas savoir.

Mais pourquoi utiliser BP au lieu de SP ici, le résultat ne sera pas le même ou c'est juste un question de sûreté ?

[Obsidian]

Avant tout, j'ai envie de dire qu'un petit « gcc -S » produit le code assembleur généré à partir du C et permet de voir comment un simple main(int argc,char ** argv) va effectivement être traduit.

Pour EBP, il vaut mieux s'y fier plutôt qu'à ESP parce que tu as le droit d'utiliser la pile dans ta fonction, spécialement si tu codes en assembleur. « BP » signifie Base Pointer et c'est lui que l'on utilise, en général, quand on ouvre un cadre de pile. C'est-à-dire qu'en entrant dans la fonction, on empile EBP, puis on copie ESP dans EBP, puis, enfin, on retranche une valeur n à ESP pour réserver de la place aux variables locales. Comme ESP peut bouger, donc, on utilise EBP comme référence.

Cette manière de faire a deux avantages :

— En cas d'exception, ou de sortie « prématurée » de la fonction avec exit(), goto, ou même un simple return, tu peux immédiatement ramener le pointeur de pile à son état initial et, de là, dépiler les registres et remonter à la fonction précédente ;
— Ça te permet de ne pas avoir à systématiquement ouvrir de cadre de pile, ce qui est particulièrement intéressant lorsque tu utilises des fonctions récursives.

[golden boy]

D'accord, convaincu. J'avoue ne jamais avoir trop compris dans le détail les prologues de fonctions, mais je vois pourquoi il est préférable de se servir de BP à présent.