Hello World en 15 lignes et plus

Salutations à vous tous,

Je vous souhaite une très bonne journée ou soirée. Aujourd'hui, je vais vous apprendre les bases de comment coder avec un langage assembleur et son assembleur respectif.

Une préface avant de commencer. Bien que mes deux articles précédents semblent avoir mis de l'emphase sur le fait que les langages assembleurs ne sont plus
énormément utilisés, leurs utilités sont toujours essentielles. Surtout pour les composantes vitales de nos ordinateurs et autres périphériques comme les CPUs, cartes graphiques et systèmes embarqués.
Leurs présences sont petites, mais leurs impacts sont gigantesques. De plus, bien que les langages assembleurs ne sont plus si populaires de nos jours,
ils sont quand même utiles et intéressants à apprendre pour plusieurs raisons, comme:

• Comment les programmes s'interfacent avec le système d'exploitation, le processeur et le BIOS ;
• Comment les données sont représentées dans la mémoire et dans d’autres périphériques externes ;
• Comment le processeur accède et exécute les instructions ;
• Comment les instructions accèdent et traitent les données ;
•  Comment un programme accède aux périphériques externes.

Une autre chose à savoir est que les langages assembleurs ont des IDEs spécifiques à eux qui doivent être utilisés pour pouvoir exécuter le code écrit. Ils sont appelés "assembleur".
Et dans ce contexte, l'assembleur que je vais utiliser pour aujourd'hui est NASM, mais il y a plusieurs autres qui peuvent être considérés comme MASM(Microsoft Assembler), TASM(Borland Turbo Assembler) et GAS(GNU assembler).

Pour ce tutoriel, j'utiliserais le langage assembleur X86.
Maintenant, commençons avec les bases.

La structure

Un code écrit avec un langage assembleur est généralement séparé en trois parties.

- Données
- BSS
- Texte

1) Syntaxe de déclaration: section.data 
La section donnée est utilisée pour la déclaration de données initialisées et les constantes, et elles ne peuvent pas être changées durant l'exécution. 
Dans cette section, vous pouvez déclarer des valeurs constantes, des noms de fichiers ou la taille de tampon et, etc.

2) Syntaxe de déclaration: section.bss
Cette section est utilisée pour déclarer des variables.

3) Syntaxe de déclaration: section.text 
Cette section est où le code va être écrit. On écrit global_start après pour indiquer au noyau l'endroit où l'exécution devrait commencer:

section.text

global _start
_start:

Les commentaires

Pour laisser un commentaire, il suffit seulement de laisser un ";" au début d'une ligne de code avant de l'écrire.
Ou sinon, le commentaire peut aussi être laissé après une ligne de code en écrivant un ";" après celui-ci:

add eax, ebx     ; adds ebx to eax

Les déclarations

Les langages assembleurs ont trois types de déclarations.

- Instructions
- Pseudo-Ops
- Macros

1) Les instructions parlent au processeur et lui disent quoi faire. Chaque instruction est composée d'un code d'opération et donc ça génère une instruction de type langage machine.
2) Les pseudo-ops disent à l'assembleur au sujet de nombreux aspects du processus assembleur. Ceux-ci ne sont pas exécutables et ils ne génèrent pas d'instructions.
3) Les macros sont un mécanisme de substitution de texte.

La syntaxe

Les déclarations sont faites une à la fois, donc une part ligne, et chacun d'entre eux suivent cette structure:

[label]   mnemonic   [operands]   [;comment]   //ang
-----------------------------------------------

[étiquette]   mnémonique   [opérandes]   [;commentaire]   //fra

Tous les éléments entourés par les crochets sont optionnels.
Une instruction de base est composée de deux parties, la première étant le nom de l'instruction (mnémonique) qui est à 
être exécuté, et la deuxième est les opérandes/paramètres de ladite commande.

Hello World

Voici un exemple de comment afficher "Hello World" avec X86 en utilisant l'assembleur NASM:

section    .text
  global _start     ;must be declared for linker (ld)
    
_start:                ;tells linker entry point
  mov    edx,len     ;message length
  mov    ecx,msg     ;message to write
  mov    ebx,1       ;file descriptor (stdout)
  mov    eax,4       ;system call number (sys_write)
  int    0x80        ;call kernel
    
  mov    eax,1       ;system call number (sys_exit)
  int    0x80        ;call kernel

section    .data
msg db 'Hello, world!', 0xa  ;string to be printed
len equ $ - msg     ;length of the string

Ou avec une image:

Ou un autre exemple:

L'assemblage

Pour voir le résultat de ce code, il faut l'assembler en premier.

• La première étape est, comme je l'ai décrit dans mon article précédent, 
  de créer un fichier .asm, ou dans ce contexte, le sauvegarder en un fichier .asm
• La deuxième étape est de rester dans le même directoire où on a enregistré le fichier.
• La troisième étape est de taper dans NASM la commande d'assemblage: nasm -f elf hello.asm

• Si aucune erreur ne s'ensuivent, alors un fichier appelé le nom du fichier .asm précédent avec comme type ".o" devrait être créé.
  Par exemple, si nous avons appelé notre fichier bonjour.asm, alors lorsque 
  la commande est entrée et que tout est bien effectué, un fichier 
  additionnel appelé bonjour.o devrait aussi être créé.

• La quatrième étape, pour rendre le code exécutable, est de lier les deux fichiers ensemble en entrant dans la console NASM:
  ld -m elf_i386 -s -o [NOM FICHIER] [NOM FICHIER].o

Maintenant, en tapant ./[NOM FICHIER] dans le terminal, le code devrait être exécuté.

En bref, voici les notions les plus basiques au sujet des langues assembleurs. J'irais plus en détail dans mon prochain article au sujet de la syntaxe et, etc., du code "hello world" que j'ai montré dans cet article.

Alors, rester à l'afût et je vous souhaite une bonne journée (ou soirée)!

À la prochaine.

«Assembly - Basic Syntax», TutorialsPoint,  https://www.tutorialspoint.com/assembly_programming/assembly_basic_syntax.htm (Page consultée le 23 février 2024)

«Hello World with NASM Assembler», DEV_DUNGEON,  https://www.devdungeon.com/content/hello-world-nasm-assembler (Page consultée le 23 février 2024)