Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

x86 32-bits / 64-bits Assembleur Discussion :

Nasm sous Linux


Sujet :

x86 32-bits / 64-bits Assembleur

  1. #1
    Membre habitué
    Nasm sous Linux
    Bonjour à tous,

    Par simple curiosité et par nostalgie des très rapides introductions que j'ai pu avoir sur l'ASM il y a une 10aine d'années, je me met aujourd'hui à l'assembleur avec nasm (je me passe de la syntaxe Gas)
    L'objectif est ici de mieux comprendre les interactions au niveau hardware, que ce soit pour des ordinateurs comme pour des microcontrôleurs. Quand on voit ce que certains faisaient dans le début des années 90 avec des programmes de 64Ko, ça laisse rêveur.

    Quoi qu'il en soit, j’essaie de faire tourner le morceau de code présent sur ce site, ici : introduction à Nasm (et je suis en parallèle cette page), mais soit Nasm, soit ld me retournent une erreur lors de la compilation ou du linkage.

    Ou puis-je trouver un minimum de doc concernant la compilation / linkage de programmes Nasm sous linux ? Malheureusement, dans mon cas, les pages man me semblent nécessiter quelques explications supplémentaires.

    pour info, je suis sous Mint Tessa Noyau 4.15.0-47 Proc Intel

  2. #2
    Expert éminent
    Au risque de te décevoir , tu ne pourra pas interagir avec la hardware que ça soit en assembleur ou en C ,vu que l'OS t’empêchera de le faire , d'ailleurs la communication avec le Hardware peut se faire à 100% en C (je précise parce que c'est une erreur courante de penser que seul l'asm peut communiquer avec le hard).
    Donc si ton but est de comprendre comme marche un ordi , alors l'asm sur PC n'est pas vraiment adapté.

    Sinon un hello world de Nasm + Linux + ligne de command :
    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
     
    ;  hello.asm  a first program for nasm for Linux, Intel, gcc
    ;
    ; assemble:	nasm -f elf -l hello.lst  hello.asm
    ; link:		gcc -o hello  hello.o
    ; run:	        hello 
    ; output is:	Hello World 
     
    	SECTION .data		; data section
    msg:	db "Hello World",10	; the string to print, 10=cr
    len:	equ $-msg		; "$" means "here"
    				; len is a value, not an address
     
    	SECTION .text		; code section
            global main		; make label available to linker 
    main:				; standard  gcc  entry point
    _start:
     
    	mov	edx,len		; arg3, length of string to print
    	mov	ecx,msg		; arg2, pointer to string
    	mov	ebx,1		; arg1, where to write, screen
    	mov	eax,4		; write sysout command to int 80 hex
    	int	0x80		; interrupt 80 hex, call kernel
     
    	mov	ebx,0		; exit code, 0=normal
    	mov	eax,1		; exit command to kernel
    	int	0x80		; interrupt 80 hex, call kernel

  3. #3
    Membre confirmé
    le tuto de benoitM est bien fait mais plutôt orienté Windows et dos
    personnellement je ne connait rien a Nasm parce que j'utilise Fasm qui est a mon avis très bien foutu (déjà pas besoin de linkage) avec une bonne documentation (hélas en anglais) et fonctionne sur tout un tas d'OS (même des Hobby OS) et la seule documentation dont j'ai eu besoin c'est la description des appels système: http://www.lxhp.in-berlin.de/lhpsysc1.html

  4. #4
    Membre habitué
    Bonjour, et merci pour ce retour.

    Mon but n'est pas spécialement de rester sur PC justement, mais dans l'immédiat, je commence par là.
    Après, je sais que le C permet cette même communication (qu'elle soit à 100% ou non avec le hardware) et qu'il est plus simple de programmer en C. Idem pour les microcontrôleurs, rien n'empêche de coder en C pour ces derniers mais bon. Je m'intéresse tout de même à l'assembleur. Le simple fait de pouvoir me faire un bootloader pour mon vieux 386 qui traîne quelque part et où faire un driver pour 2 ventilos branchés en port com / RS232 peut être fun aussi.

    Merci bien pour ce petit hello world qui me lancera enfin dans cette aventure.

    Pour Masm, Nasm, Fasm, voire gas... Peu importe, tout que je me trouve une syntaxe, que j'y colle et que j'arrive à la compiler sur tout et n'importe quoi. Reste à voir la syntaxe. Tu as un code minimal pour Fasm aussi que je me fasse une idée ? comme ça je test les deux d'un coup et je verrais bien lequel me plaît le mieux.


    Merci.



    ----- EDIT -----
    Je viens de tester le hello word mais :
    ; assemble: nasm -f elf -l hello.lst hello.asm
    ; link: gcc -o hello hello.o
    me donne :
    Architecture i386 du fichier incompatible avec la sortie i38686_64

    Si j'essaie de forcer GCC -m32, j'ai bien plus d'erreurs... Dois-je absolument repasser à un linux 32b ?

    Pour info, étant sur ma machine windows, je compile sur un linux en VM. Je testerais sur ma machine linux tout à l'heure ; c'est peut être là le bug ??

  5. #5
    Expert éminent
    Ma réponse n'était pas "fais le en C" mais plutôt que la communication du hardware n'était pas spécifique à l'asm , donc que tu peux apprendre le hardware indépendament du langage utilisé.

    Pour du x64 :
    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
     
    global _start
     
    section .text
     
    _start:
      mov rax, 1        ; write(
      mov rdi, 1        ;   STDOUT_FILENO,
      mov rsi, msg      ;   "Hello, world!\n",
      mov rdx, msglen   ;   sizeof("Hello, world!\n")
      syscall           ; );
     
      mov rax, 60       ; exit(
      mov rdi, 0        ;   EXIT_SUCCESS
      syscall           ; );
     
    section .rodata
      msg: db "Hello, world!", 10
      msglen: equ $ - msg


    commande :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    nasm -f elf64 -o hello.o hello.asm
    ld -o hello hello.o
    ./hello

  6. #6
    Membre confirmé
    un petit exemple pour fasm:
    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
     
    ;compiler avec la commande "fasm hellofasm.asm helloworld.elf"
     
     
    format ELF executable 3 ;executable i386 pour linux
    entry _start
     
     
    segment readable executable
     
     _start:
    mov eax,4  ;ecrire
    mov ebx,1  ;dans console
    mov ecx,msg  ;adresse du message
    mov edx,finmsg-msg ;taille du message
    int 80h
     
    mov	eax,1     ;fin du programme
    xor	ebx,ebx   
    int	80h
     
     
     
    segment readable writeable
     
    msg:
    db "bonjour!"
    finmsg:

  7. #7
    Membre habitué
    Bonjour, merci à vous pour ces morceaux de code. Ça m'aidera à m'y mettre.

    il me reste à choisir entre FASM et NASM ; je trouverais bien ce qui me botte le plus.

    Merci encore.

  8. #8
    Responsable Systèmes

    Architecture i386 du fichier incompatible avec la sortie i38686_64
    Tu peux assembler du code 32 bits et le faire fonctionner sur x64, mais il te faut donner la directive d'assemblage [BITS 32]
    Ma page sur developpez.com : http://chrtophe.developpez.com/ (avec mes articles)
    Mon article sur la création d'un système : http://chrtophe.developpez.com/tutor...s/minisysteme/
    Mon article sur le P2V : http://chrtophe.developpez.com/tutoriels/p2v/
    Consultez nos FAQ : Windows, Linux, Virtualisation