Assembly Playground

Écrivez, exécutez et partagez des extraits de code - sans installation.

main.asm

Alice

Output

Click Run to see the output here.

section .data
    prompt db 'Hello, '
    prompt_len equ $ - prompt
    bang db '!', 10
    bang_len equ $ - bang

section .bss
    name resb 64

section .text
    global _start

_start:
    ; read up to 63 bytes of the name from stdin (fd 0)
    mov rax, 0          ; sys_read
    mov rdi, 0          ; stdin
    mov rsi, name
    mov rdx, 63
    syscall
    mov r12, rax        ; bytes read

    ; drop the trailing newline if present
    cmp r12, 0
    jle no_trim
    mov bl, [name + r12 - 1]
    cmp bl, 10
    jne no_trim
    dec r12
no_trim:

    ; write "Hello, "
    mov rax, 1          ; sys_write
    mov rdi, 1          ; stdout
    mov rsi, prompt
    mov rdx, prompt_len
    syscall

    ; write the name
    mov rax, 1
    mov rdi, 1
    mov rsi, name
    mov rdx, r12
    syscall

    ; write "!\n"
    mov rax, 1
    mov rdi, 1
    mov rsi, bang
    mov rdx, bang_len
    syscall

    ; exit(0)
    mov rax, 60         ; sys_exit
    xor rdi, rdi
    syscall

Exécutez de l'Assembly en ligne dans votre navigateur

Ceci est un compilateur Assembly en ligne et gratuit pour le code x86-64 écrit en syntaxe NASM. Tapez votre programme, appuyez sur Exécuter, et Coddy l'assemble avec nasm -f elf64, le lie avec ld et exécute l'exécutable Linux résultant côté serveur, puis vous montre stdout, stderr et le code de sortie. Il n'y a rien à installer : ni NASM, ni éditeur de liens, ni machine virtuelle, ni compilateur croisé.

Le programme de départ est un point d'entrée _start complet qui lit une ligne de l'entrée standard et renvoie un message d'accueil en utilisant les appels système bruts read, write et exit, sans libc. C'est ainsi que l'assembleur fonctionne vraiment : vous déplacez les arguments dans rax/rdi/rsi/rdx, vous invoquez syscall, et le noyau fait le reste. Utilisez le panneau stdin sous l'éditeur pour fournir de l'entrée à votre programme à chaque Exécution, exactement comme rediriger des données vers un vrai binaire.

Ce qui rend ce playground Assembly utile

Toolchain NASM x86-64 réelle. Votre source est assemblée avec nasm -f elf64 et liée avec ld sous Linux, les mêmes commandes que vous taperiez localement, donc ce qui s'exécute ici correspond à ce qui s'exécute sur une vraie machine.
Appels système Linux directs. Le programme de départ utilise read, write et exit via l'instruction syscall sans libc entre les deux, vous voyez donc exactement comment les registres transportent les arguments et les valeurs de retour.
Prise en charge de l'entrée standard. Envoyez des octets à votre programme via le panneau stdin et lisez-les avec l'appel système 0 : utile pour les exercices classiques « lire un nom, afficher un message d'accueil » et au-delà.
Aucune configuration, retour instantané. Pas d'installation de NASM, pas de drapeaux d'éditeur de liens à retenir, pas d'erreurs de permission : ouvrez la page et l'éditeur est prêt. Les erreurs de l'assembleur et de l'éditeur de liens reviennent directement dans la sortie.

Ce que vous pouvez essayer dans le playground Assembly

Affichez une chaîne fixe avec un seul appel système write, puis un exit(0) propre : le plus petit programme x86-64 complet, et le moyen le plus rapide de voir comment _start et syscall s'articulent.
Lisez depuis stdin dans un tampon .bss, retirez le retour à la ligne final et renvoyez-le : le motif derrière presque tous les exercices d'assembleur pilotés par l'entrée.
Additionnez deux nombres dans des registres et convertissez le résultat en chiffres ASCII à la main, afin de pouvoir le write. C'est ainsi que vous apprenez que l'assembleur n'a pas de print, seulement des octets et des appels système.

FAQ du compilateur Assembly en ligne

Quel assembleur et quelle syntaxe ce playground utilise-t-il ?

Il utilise NASM (le Netwide Assembler) avec la syntaxe Intel, ciblant x86-64 Linux. Votre code est assemblé avec nasm -f elf64 et lié avec ld. Si vous venez de la syntaxe AT&T/GAS (le style %rax, movq), réécrivez dans le style Intel de NASM : mov rax, 1, section .text, global _start.

Dois-je installer NASM ou un éditeur de liens pour utiliser ceci ?

Non. La toolchain complète s'exécute côté serveur dans un conteneur isolé. Vous écrivez du NASM dans le navigateur, appuyez sur Exécuter, et Coddy assemble et lie votre programme pour vous. Il n'y a rien à installer localement : ni NASM, ni ld, ni VM Linux.

Comment lire l'entrée en assembleur ici ?

Utilisez l'appel système read (numéro 0) : mettez 0 dans rax (sys_read), 0 dans rdi (stdin), l'adresse d'un tampon dans rsi et le nombre maximal d'octets dans rdx, puis exécutez syscall. Tout ce que vous tapez dans le panneau stdin sous l'éditeur est fourni à votre programme lors de l'Exécution. Le programme de départ montre le motif complet, y compris le retrait du retour à la ligne final.

Pourquoi mon programme a-t-il besoin de _start au lieu de main ?

Parce que le programme de départ est lié avec ld et sans runtime C. main est une convention de libc : le code de démarrage C l'appelle après avoir tout mis en place. Avec un simple lien ld, il n'y a pas de libc, donc le noyau saute directement à l'étiquette _start, c'est pourquoi chaque programme ici définit global _start. C'est à vous de sortir proprement avec l'appel système exit (numéro 60) à la fin.

Puis-je apprendre l'assembleur avec ce compilateur même en tant que débutant ?

Oui. Commencez par le programme de salutation, changez la chaîne et observez la sortie. Essayez ensuite de lire de l'entrée, de faire de l'arithmétique dans les registres et de convertir des nombres en texte à la main. Comme il n'y a aucune configuration et que chaque Exécution donne un retour instantané, vous pouvez itérer rapidement, ce qui est le moyen le plus rapide de développer une intuition des registres, de la mémoire et des appels système.

Outils utiles pour Assembly

Outils gratuits dans le navigateur qui s'associent bien avec le Playground Assembly - tout fait partie de Coddy.

Intégrer l'éditeur Assembly