Salutations à tous,
Bonne journée et où bonne soirée! Aujourd’hui sera une continuation de mon article précédent. Nous aborderons les spécifiques de chaque section d’une structure d’un programme écrit avec un langage assembleur et les registres de stockage de données.
Segments
Alors pour commencer, j’ai décrit précédemment qu’un code assemblée était composé de trois sections: .data, .bss, .text
Mais un spécifique a rajouté est que c’est la section peuvent être regroupé en segment, trois segments.
Data (données) : Ce segment est représenté par et contient les sections .date et .bss .
Code (code) : Ce segment est représenté par et contient la section .text .
Stack (stack) : Ce segment contient toutes les valeurs des données passées dans les fonctions et procédures dans le programme.
Pourquoi est-ce que je vous explique tout cela? C'est parce que la plupart du temps, un code assemblée est écrit en suivant le modèle de mémoire segmenté.
Ce modèle est séparé en trois sections, et ces trois sections sont exactement celles que je viens juste de présenter en haut.
Si nous modifions le code qui permet d'afficher "Hello World" de mon article précédent au format segments, ça ressemblerait à cela:
segment .text ;code segment
global _start ;must be declared for linker
_start: ;tell 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 kernelmov eax,1 ;system call number (sys_exit)
int 0x80 ;call kernelsegment .data ;data segment
msg db 'Hello, world!',0xa ;our dear string
len equ $ - msg ;length of our dear string
Observez les segments déclarés: segment.text - segment.data
Registres
Les outils principaux utilisés pour écrire des programmes avec le langage assembleur X86 sont les registres.
Pour être plus exacte, on les appelle les registres processeur car ceux-ci sont utilisés dans le traitement des données du processeur (CPU).
Pour accélérer les opérations fait dans le processeur par rapport à un code écrit en un langage assembleur, celui-ci inclura des lieux de stockage de mémoire interne, qui sont aussi appelés registres en d'autres mots.
Avec ces trois phrases que j'ai écrites, ils peuvent être résumés en trois points:
- Les registres sont essentiels à l'écriture de code en langage assembleur X86
- Ces registres sont capables d'accélérer et si bien utilisés, capables aussi d'optimiser la vitesse du traitement des données dans un processeur (CPU).
- lieux de stockage de mémoire interne = registres
Juste au cas où que vous ne savez pas ce que "lieux de stockage de mémoire interne" veut dire, voici une courte description:
Les registres, ou lieux de stockage de mémoire interne, permettent de stocker des éléments de données qui vont être traitées sans à avoir accédé à la mémoire. Par contre, il y a un nombre limité de registres construit sur la puce d'un processeur (CPU).
Les catégories de registres
Dans l'architecture IA-32, il y a 10 registres 32-bit et 6 registres 16-bit qui sont séparés en trois catégories:
- Les registres généraux
- Les registres de contrôles
- Les registres de segment
Et les registres généraux sont séparés encore en trois catégories:
- Les registres de données
- Les registres de pointeurs
- Les registres d'index
Les registres de données:
Il y a quatre registres de données 32-bit qui sont utilisés pour des opérations arithmétiques et logiques.
Ces registres peuvent être utilisés de trois manières:
- De manière complète (32-bit)
- De manière à moitié complète (16-bit)
- De manière à quart complet (8-bit)
AX: L'accumulateur primaire
- Ceci est utilisé dans les input/ouput de la plupart des instructions arithmétiques. Un exemple serait que si je veux faire une multiplication, un de mes opérandes est stocké dans EAX, ou AX, ou AL dépendant de sa taille.
BX: Le registre de base
- Ceci est utilisé pour l'adressage d'index, ou en d'autres mots, c'est utilisé comme un pointeur de base pour l'accès mémoire.
CX: Le registre compteur
- Ceci est utilisé pour enregistrer les
DX: Le registre de données de nombre de boucle dans une opération itérative.
- Ceci est utilisé pour les opérations d'entrées et de sorties. Aussi utilisé avec les registres AX et DX pour des opérations concernant la division de valeur large.
Les registres pointeurs:
Ces registres sont considérés dans deux formats (32 et 16 bit).
-EIP, ESP, EBP (32-bit)
-IP, SP, BP (16-bit)
Et elles sont séparées en trois catégories:
-Pointeur instruction (IP): Celui-ci met en stockage l'adresse de la prochaine instruction à être exécuté.
-Pointeur stack (SP): Celui-ci offre la valeur de décalage dans le stack du programme. En d'autres mots, ça tient l'adresse en haut du stack.
-Pointeur de base (BP): Celui-ci aide principalement à référencer les variables de paramètre passé dans un sous-programme. En d'autres mots, ça tient l'adresse en bas du stack.
Les registres index:
Ces registres sont considérés dans deux formats (32 et 16 bit).
-ESI, EDI (32-bit)
-SI, DI (16-bit)
-Index de source (SI): Utilisé comme l'index source pour les opérations string.
-Index de destination (DI): Utilisé comme l'index de destination pour les opérations string.
Les registres de contrôle:
Les instructions de registre pointeur 32-bit et de registres flags 32-bit forment les registres de contrôle.
Ceux-ci sont souvent utilisés pour faire des comparaisons, calculs mathématiques, instructions conditionnelles et changer la statut des flags.
Ils tiennent le statut du processeur. Chaque bit tient le paramètre d'un statut spécifique de la dernière introduction.
Voici les registres les plus communs:
-Overflow Flag (OF)
-Direction Flag (DF)
-Interrupt Flag (IF)
-Trap Flag (TF)
-Sign Flag (SF)
-Zero Flag (ZF)
-Auxiliary carry Flag (AF)
-Parity Flag (PF)
-Carry Flag (CF)
Ces registres sont aussi appelés parfois les registres EFLAGS.
Les registres de segment:
Ces registres, je les ai décrits au début de cet article. Il y en a trois: Code, Données et Stack, ou CS, DS et SS.
Voici un autre exemple avec des sections où j'ai annoté avec //:
section .text //DÉBUT SEGMENT CODE
global _start ;must be declared for linker (gcc)
_start: ;tell linker entry point
mov edx,len ;message length //ON PREND L'ENTRÉE DE LA TAILLE DU MESSAGE
mov ecx,msg ;message to write //ON PREND L'ENTRÉE DU CONTENU DU MESSAGE
mov ebx,1 ;file descriptor (stdout)
mov eax,4 ;system call number (sys_write)
int 0x80 ;call kernel
mov edx,9 ;message length //ON DÉFINIT LA TAILLE, QUI EST DE NEUF
mov ecx,s2 ;message to write //ON DÉFINIT LE NOMBRE DE LIGNE QU'ON VEUT AFFICHER, QUI EST DEUX
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 //DÉBUT DU SEGMENT DE DONNÉES
msg db 'Displaying 9 stars',0xa ;a message //ON MET EN PLACE LA PREMIÈRE LIGNE MESSAGE
len equ $ - msg ;length of message //DÉFINITION DE SA TAILLE
s2 times 9 db '*' //ON MET EN PLACE LA DEUXIÈME LIGNE MESSAGE
Et tous cela affiche ces deux lignes:
Displaying 9 stars
*********
Alors j'espère que vous avez aimé cet article. Le tutoriel n'est pas encore fini, on continuera dans le prochain article.
Donc à plus tard!
(Poser vos questions si vous en avez, moi même je ne peux pas affirmer que mes explications sont 100% compréhensibles. Alors, ne soyez pas gêné!)
«Assembly - Basic Syntax», TutorialsPoint, https://www.tutorialspoint.com/assembly_programming/assembly_basic_syntax.htm (Page consultée le 2 mars 2024)
«X86 Registers», EECG UTORONTO, https://www.eecg.utoronto.ca/~amza/www.mindsec.com/files/x86regs.html (Page consultée le 2 mars 2024)
«Stack Pointer», Tech Target, https://www.techtarget.com/whatis/definition/stack-pointer (Page consultée le 2 mars 2024)
«Learn Assembly Programming - Introduction to Registers», Daniel Ross, YouTube, https://www.youtube.com/watch?v=79twPkPwNfA (Page consultée le 2 mars 2024)
«x86 Assembly - 2 - 16-bit Registers», Astral Orchid, YouTube, https://www.youtube.com/watch?v=3GF1iXsa6PE (Page consultée le 2 mars 2024)
Commentaires