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 segmentNom anglaisObjectifSection correspondante
Segment de codeSegment de codeStocke les instructions machine exécutablessection .text
Segment de donnéesSegment de donnéesStocke les variables globales initialiséessection .data
Segment de pileSegment de pileStocke les informations d'appel de fonction et les variables localesGé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

; Chemin du fichier : code_segment.asm
; 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

; Chemin du fichier : data_segment.asm
; 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

; Chemin du fichier : bss_segment.asm
; 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 segmentNom complet en anglaisObjectif
CSSegment de codePointe vers le segment de code, en stockant l'adresse de base du segment où résident les instructions en cours d'exécution
DSSegment de donnéesPointe vers le segment de données, en stockant l'adresse de base du segment pour la plupart des accès aux données
SSSegment de pilePointe vers le segment de pile, en stockant l'adresse de base du segment où réside la pile
ESSegment supplémentaireRegistre de segment supplémentaire, utilisé pour des segments de données supplémentaires tels que les opérations sur les chaînes
FSUsage généralRegistre de segment à usage général, souvent utilisé pour le stockage local au thread
GSUsage généralRegistre 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émoireAdresse de segment × 16 + offsetLe sélecteur de segment consulte la table des descripteurs + offset
Mémoire maximale1MB4GB (32 bits)
Protection mémoireAucune protectionDispose d'une protection au niveau des pages et des segments
MultitâcheNon pris en chargePris en charge
Mode d'adressagesegment:offsetsélecteur:offset (via table des descripteurs)

Ce 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.

Autres extensions