Langage d'assemblage - Segmentation de la mémoire
La segmentation mémoire est un concept fondamental dans l'architecture x86, déterminant comment un programme organise le code, les données et l'espace de pile en mémoire.
Pourquoi la segmentation est nécessaire
En mode réel x86, le CPU utilise des registres 16 bits, mais il doit accéder à un espace mémoire de 1MB (adresses 20 bits).
Un registre 16 bits ne peut représenter qu'une plage de 64KB (2^16 = 65536), ce qui est loin d'être suffisant.
La solution d'Intel consiste à diviser la mémoire ensegments (Segment), chaque segment possède une adresse de base et un décalage, et viaadresse de segment + décalage, l'adresse physique complète est formée.
Formule de calcul de l'adresse physique :
物理地址 = 段地址 × 16 + 偏移地址
Bien qu'en mode protégé (32 bits), le mécanisme de segmentation soit davantage utilisé pour la protection de la mémoire et le contrôle des permissions, comprendre la segmentation reste crucial pour comprendre la structure des programmes en assembleur.
Trois segments de base
Un programme en assembleur typique utilise trois segments principaux :
| Nom du segment | Nom anglais | Objectif | Section correspondante |
|---|---|---|---|
| Segment de code | Segment de code | Stocke les instructions machine exécutables | section .text |
| Segment de données | Segment de données | Stocke les variables globales initialisées | section .data |
| Segment de pile | Segment de pile | Stocke les informations d'appel de fonction et les variables locales | Géré automatiquement par le système d'exploitation |
Segment de code (.text)
Le segment de code stocke toutes les instructions machine du programme et est une région mémoireen lecture seule et exécutable.
Lors du chargement d'un programme, le système d'exploitation mappe le segment de code sur des pages mémoire en lecture seule afin d'empêcher le programme de modifier accidentellement des instructions.
Exemple
; Démontre l'utilisation du segment de code
section .text ; Début du segment de code
global _start
_start:
mov eax, 1 ; Ces instructions sont toutes stockées dans le segment de code
mov ebx, 0
int 0x80
; Ce qui suit est une fonction auxiliaire, également stockée dans le segment de code
my_function:
mov eax, 42
ret
Segment de données (.data)
Le segment de données stockeles variables globales initialisées du programme。
Le segment de données est lisible et inscriptible, et son contenu peut être modifié pendant l'exécution du programme.
Exemple
; Démontre l'utilisation du segment de données
section .data
; Définir des variables initialisées de différents types
msg db 'Hello, example!', 0 ; Variable chaîne (séquence d'octets)
count db 100 ; Variable d'octet, valeur initiale 100
pi dd 314159 ; Variable mot double, stockant l'approximation de π × 100000
array db 1, 2, 3, 4, 5 ; Tableau d'octets
section .text
global _start
_start:
; Lire les variables depuis le segment de données
mov al, [count] ; Charger la valeur de count (100) dans le registre al
; ...
mov eax, 1
mov ebx, 0
int 0x80
Segment BSS (.bss)
Le segment BSS (Block Started by Symbol) stockedes variables globales non initialisées。
Contrairement au segment de données, le segment BSS n'occupe pas d'espace réel dans le fichier exécutable ; il ne fait que recevoir de la mémoire allouée et mise à zéro par le système d'exploitation lors du chargement du programme.
Exemple
; Démontre l'utilisation du segment BSS
section .bss
buffer resb 256 ; Réserver un tampon de 256 octets (non initialisé)
num_array resd 100 ; Réserver 100 mots doubles (400 octets)
section .data
; Données initialisées
section .text
global _start
_start:
; Utiliser le tampon dans le segment BSS
mov byte [buffer], 'A' ; Écrire le caractère 'A' dans le tampon
; ...
mov eax, 1
mov ebx, 0
int 0x80
Placer des données non initialisées dans le segment BSS au lieu du segment .data peut réduire la taille du fichier exécutable. Par exemple, un tampon non initialisé de 10KB n'occupe aucun espace fichier dans le segment BSS, mais s'il est placé dans le segment .data, il augmenterait le fichier de 10KB.
Registres de segment
L'architecture x86 possède 6 registres de segment, utilisés pour suivre les segments actuellement utilisés :
| Registre de segment | Nom complet en anglais | Objectif |
|---|---|---|
| CS | Segment de code | Pointe vers le segment de code, en stockant l'adresse de base du segment où résident les instructions en cours d'exécution |
| DS | Segment de données | Pointe vers le segment de données, en stockant l'adresse de base du segment pour la plupart des accès aux données |
| SS | Segment de pile | Pointe vers le segment de pile, en stockant l'adresse de base du segment où réside la pile |
| ES | Segment supplémentaire | Registre de segment supplémentaire, utilisé pour des segments de données supplémentaires tels que les opérations sur les chaînes |
| FS | Usage général | Registre de segment à usage général, souvent utilisé pour le stockage local au thread |
| GS | Usage général | Registre de segment à usage général, souvent utilisé pour le stockage local au thread |
En mode protégé 32 bits, les programmeurs n'ont généralement pas besoin de définir manuellement les registres de segment ; le système d'exploitation et l'éditeur de liens s'en chargent.
Diagramme de segmentation de la mémoire
La disposition mémoire d'un programme en cours d'exécution est la suivante :
La disposition mémoire approximative d'un programme en cours d'exécution est la suivante :
高地址 +-------------------+ | 栈 (Stack) | <-- SS:ESP 指向栈顶 | 向下增长 | +-------------------+ | | | 空闲内存 | | | +-------------------+ | BSS 段 (.bss) | 未初始化的全局变量 +-------------------+ | 数据段 (.data) | 已初始化的全局变量 +-------------------+ | 代码段 (.text) | 程序指令(只读) +-------------------+ | 保留区域 | 操作系统使用 +-------------------+ 低地址
Mode réel vs mode protégé
| Fonctionnalité | Mode réel (16 bits) | Mode protégé (32 bits) |
|---|---|---|
| Adressage mémoire | Adresse de segment × 16 + offset | Le sélecteur de segment consulte la table des descripteurs + offset |
| Mémoire maximale | 1MB | 4GB (32 bits) |
| Protection mémoire | Aucune protection | Dispose d'une protection au niveau des pages et des segments |
| Multitâche | Non pris en charge | Pris en charge |
| Mode d'adressage | segment:offset | sélecteur:offset (via table des descripteurs) |
Autres extensionsCe tutoriel présente principalement la programmation en assembleur en mode protégé 32 bits. Dans ce mode, la notion de segments relève davantage d'une division logique des régions mémoire, les adresses physiques étant gérées par le mécanisme de pagination. Vous pouvez simplement comprendre les sections .data/.bss/.text comme des marqueurs des différentes parties du programme en mémoire.