Словарь основных терминов

⏱️ 1. Первый массив за 2 минуты

Начнём с самого простого примера — массив из пяти чисел и вывод первого элемента:

section .data
    numbers db 10, 20, 30, 40, 50    ; Массив из 5 байтов
    
section .text
    global _start

_start:
    mov al, [numbers]                ; Загружаем первый элемент (10)
                                     ; al теперь содержит 10
    
    mov rax, 60                      ; Системный вызов exit
    xor rdi, rdi
    syscall

Что здесь происходит:

• db (define byte) объявляет массив байтов
• numbers — это метка, указывающая на начало массива
• [numbers] — обращение к первому элементу через квадратные скобки

Запустите этот код — он успешно скомпилируется и выполнится. Теперь разберёмся, как это работает детально.

🤔 2. Зачем нужны массивы в ассемблере?

В отличие от языков высокого уровня, в ассемблере вы управляете каждым байтом памяти вручную. Массивы здесь — это не просто удобный тип данных, а единственный способ организовать память так, чтобы код оставался читаемым и масштабируемым.

Взгляните на разницу между хранением отдельных переменных и использованием массива:

section .data
    num1 db 10
    num2 db 20
    num3 db 30
    ; ...ещё 97 переменных

section .data
    numbers db 10, 20, 30, ..., 100

Реальные применения

section .data
    message db "Hello, World!", 0    ; Массив символов с нуль-терминатором

section .data
    ; Таблица квадратов чисел 0-9
    squares db 0, 1, 4, 9, 16, 25, 36, 49, 64, 81

section .bss
    buffer resb 1024    ; Резервируем 1024 байта под буфер

📋 3. Способы объявления массивов

В NASM есть директивы для разных размеров элементов. Выбор зависит от диапазона значений и требований к памяти.

Основные директивы

Практические примеры

section .data
    ; ASCII-коды символов
    chars db 'A', 'B', 'C', 0
    
    ; Малые числа
    ages db 25, 30, 18, 45
    
    ; Смешанное (осторожно!)
    mixed db 100, 'X', 200

section .data
    ; Большие целые числа
    populations dd 1000000, 5000000
    
    ; Числа с плавающей точкой (32-bit float)
    temperatures dd 3.14, 2.71
    
    ; Можно смешивать форматы
    data dd 42, 0x2A, 0b101010  ; Всё равно 42

Специальные возможности

section .data
    zeros db 100 dup(0)        ; 100 нулевых байтов
    pattern dw 10 dup(0xFFFF)  ; 10 слов со значением 0xFFFF

section .bss
    buffer resb 512    ; Резервируем 512 байт (не инициализированы)
    matrix resw 100    ; Резервируем 100 слов (200 байт)
    bigdata resd 1000  ; Резервируем 1000 двойных слов (4000 байт)

Профессиональный приём: Выравнивание (align)

Представьте, что память — это тетрадь в клеточку, где процессор «читает» по 8 клеточек за раз.

Если ваше число случайно начинается с середины “строки” и перелезает на следующую, процессору приходится делать два чтения вместо одного и склеивать половинки. Это не только медленно, но и опасно: некоторые современные инструкции (SSE/AVX) в такой ситуации просто аварийно завершают программу.

Директива align заставляет ассемблер вставить пустые байты, чтобы данные ложились «красиво».

section .data
    flag  db 1         ; Адрес: 0x...00
    
    ; Следующий адрес: 0x...01 (нечетный!)
    
    value dq 100       ; Адрес: 0x...01
                       ; Занимает байты с 01 по 08.
                       ; Пересекает границу 8 байт!

section .data
    flag  db 1         ; Адрес: 0x...00
    
    align 8            ; Вставляет 7 пустых байт (NOP)
                       ; Следующий адрес станет 0x...08
    
    value dq 100       ; Адрес: 0x...08
                       ; Идеально попадает в "сетку" памяти

🤔 А разве компилятор не делает это сам?

В языках высокого уровня (C, C++, Rust) компилятор автоматически добавляет отступы (padding) между переменными. Но NASM — это не компилятор. Он создаёт структуру памяти с точностью до байта именно так, как вы написали. Если вы не напишете align, данные будут лежать вплотную, даже если это вредит производительности. В ассемблере вся ответственность за память лежит на вас.

Золотое правило выравнивания

Ставьте align X перед данными размером X байт:

🗺️ 4. Как работает адресация массивов

Концепция: Массив как улица с домами

Представьте массив как улицу с пронумерованными домами:

🏠 Дом №0    🏠 Дом №1    🏠 Дом №2    🏠 Дом №3
   [10]         [20]         [30]         [40]
Адрес: 100   Адрес: 101   Адрес: 102   Адрес: 103

• Метка массива (numbers) — это адрес первого дома (улица Пушкина, дом №0)
• Каждый дом занимает определённую площадь:
  • db: 1 байт — маленький дом
  • dw: 2 байта — средний дом
  • dd: 4 байта — большой дом

Чтобы дойти до дома №3:

• Если дома по 1 байту: идём на 3 × 1 = 3 байта вперёд
• Если дома по 2 байта: идём на 3 × 2 = 6 байтов вперёд
• Если дома по 4 байта: идём на 3 × 4 = 12 байтов вперёд

Формула адресации

Теперь та же идея в виде формулы:

$$Address = Base + (Index \times ElementSize)$$

Конкретный числовой пример:

section .data
    arr dw 10, 20, 30, 40    ; Массив начинается с адреса 0x1000

Если arr находится по адресу 0x1000 (база), то:

Размер элемента dw = 2 байта, поэтому умножаем индекс на 2.

lea rsi, [arr]      ; Теперь RSI содержит реальный адрес (например, 0x402010)

(gdb) print &arr
$1 = (<data variable, no debug info> *) 0x402010

element[3] → base_address + (3 × 2)

section .data
    arr dw 10, 20, 30, 40  ; 2-байтовые элементы

section .text
    mov rsi, arr       ; rsi = база массива
    mov rcx, 3         ; индекс элемента
    
    ; Вычисляем адрес: база + индекс×2
    mov ax, [rsi + rcx*2]  ; ax = arr[3] = 40

Режимы адресации

NASM поддерживает несколько способов доступа к элементам:

section .data
    arr db 10, 20, 30

section .text
    ; Доступ через метку напрямую
    mov al, [arr]      ; arr[0]
    mov al, [arr+1]    ; arr[1]
    mov al, [arr+2]    ; arr[2]

section .data
    arr db 10, 20, 30

section .text
    ; Доступ через регистр
    mov rsi, arr       ; rsi указывает на массив
    mov al, [rsi]      ; arr[0]
    mov al, [rsi+1]    ; arr[1]
    
    ; Индексация через регистр
    mov rcx, 2
    mov al, [rsi+rcx]  ; arr[rcx] = arr[2]

Масштабирование индекса

Для массивов с элементами больше 1 байта используйте множители *1, *2, *4, *8:

section .data
    bytes db 10, 20, 30, 40       ; 1 байт/элемент
    words dw 10, 20, 30, 40       ; 2 байта/элемент
    dwords dd 10, 20, 30, 40      ; 4 байта/элемент
    qwords dq 10, 20, 30, 40      ; 8 байтов/элемент

section .text
    mov rcx, 2                     ; Индекс = 2
    
    mov al, [bytes + rcx*1]        ; bytes[2] = 30
    mov ax, [words + rcx*2]        ; words[2] = 30
    mov eax, [dwords + rcx*4]      ; dwords[2] = 30
    mov rax, [qwords + rcx*8]      ; qwords[2] = 30

⚙️ 5. Типичные операции с массивами

section .data
    numbers dd 100, 200, 300, 400

section .text
    ; Прямой доступ
    mov eax, [numbers]      ; eax = numbers[0] = 100
    mov eax, [numbers+4]    ; eax = numbers[1] = 200
    mov eax, [numbers+8]    ; eax = numbers[2] = 300

section .data
    numbers dd 100, 200, 300, 400

section .text
    ; Через регистр-индекс
    mov rcx, 2                  ; Индекс = 2
    mov eax, [numbers + rcx*4]  ; eax = numbers[2] = 300
    
    ; Или через указатель
    lea rsi, [numbers]
    mov eax, [rsi + rcx*4]

section .data
    arr dd 10, 20, 30, 40

section .text
    ; Изменяем arr[1] на 999
    mov dword [arr+4], 999
    
    ; Через регистр
    mov rcx, 3
    mov dword [arr + rcx*4], 777    ; arr[3] = 777

section .data
    arr dd 1, 2, 3, 4, 5
    len equ ($ - arr) / 4   ; Длина массива

section .text
    xor eax, eax            ; sum = 0
    xor rcx, rcx            ; i = 0

.loop:
    cmp rcx, len
    jge .done               ; if (i >= len) goto done
    
    add eax, [arr + rcx*4]  ; sum += arr[i]
    inc rcx                 ; i++
    jmp .loop

.done:
    ; eax содержит сумму (15)

section .data
    arr dd 1, 2, 3, 4, 5
    len equ ($ - arr) / 4

section .text
    xor eax, eax            ; sum = 0
    lea rsi, [arr]          ; rsi = &arr[0]
    mov rcx, len            ; counter = len

.loop:
    add eax, [rsi]          ; sum += *rsi
    add rsi, 4              ; rsi++ (двигаем на 4 байта)
    dec rcx                 ; counter--
    jnz .loop               ; if (counter != 0) goto loop

    ; eax содержит сумму (15)

len equ ($ - arr) / 4

section .data
    arr dd 10, 20, 30, 40, 30, 50
    len equ ($ - arr) / 4
    target dd 30

section .text
    xor rcx, rcx                ; i = 0
    mov r8d, -1                 ; found_index = -1 (не найдено)

.search_loop:
    cmp rcx, len
    jge .not_found
    
    mov eax, [arr + rcx*4]      ; eax = arr[i]
    cmp eax, [target]
    je .found                   ; if (eax == target) goto found
    
    inc rcx
    jmp .search_loop

.found:
    mov r8, rcx                 ; r8 = индекс найденного элемента
    jmp .end

.not_found:
    ; r8 уже содержит -1

.end:
    ; r8 содержит индекс (2) или -1

section .data
    source dd 10, 20, 30, 40
    len equ ($ - source) / 4

section .bss
    dest resd 4                 ; Место для копии

section .text
    lea rsi, [source]           ; rsi = указатель на источник
    lea rdi, [dest]             ; rdi = указатель на назначение
    mov rcx, len                ; rcx = счётчик элементов

.copy_loop:
    mov eax, [rsi]              ; Читаем из source
    mov [rdi], eax              ; Пишем в dest
    
    add rsi, 4                  ; Переходим к следующему элементу
    add rdi, 4
    
    dec rcx
    jnz .copy_loop
    
    ; Альтернатива: использовать rep movsd
    ; mov rcx, len
    ; rep movsd                 ; Копирует rcx двойных слов из [rsi] в [rdi]

lea rsi, [source]
lea rdi, [dest]
mov rcx, len
rep movsd    ; Копирует rcx×4 байта из [rsi] в [rdi]

📝 6. Практические примеры

section .data
    numbers dd 45, 12, 89, 23, 67, 34, 91, 56
    len equ ($ - numbers) / 4

section .text
    global _start

_start:
    ; Находим максимум
    mov eax, [numbers]      ; max = numbers[0]
    mov rcx, 1              ; i = 1

.loop:
    cmp rcx, len
    jge .done
    
    mov edx, [numbers + rcx*4]  ; edx = numbers[i]
    cmp edx, eax
    jle .skip               ; if (edx <= max) skip
    
    mov eax, edx            ; max = edx

.skip:
    inc rcx
    jmp .loop

.done:
    ; eax содержит максимум (91)
    
    ; Выход с кодом = максимум (для демонстрации)
    mov rdi, rax            ; exit code
    mov rax, 60             ; sys_exit
    syscall

nasm -f elf64 max.asm -o max.o
ld max.o -o max
./max
echo $?    # Выведет 91 — код возврата программы

section .data
    numbers dd 45, 12, 89, 23, 67, 34, 91, 56
    numbers_end:
    len equ (numbers_end - numbers) / 4
    
    msg_prefix db "Максимум: "
    msg_prefix_len equ $ - msg_prefix
    
    newline db 10

section .bss
    digit_buffer resb 20

section .text
    global _start

_start:
    ; Находим максимум
    call find_max           ; Результат в eax
    
    ; СОХРАНЯЕМ результат, так как syscall его испортит
    push rax
    
    ; Выводим префикс "Максимум: "
    mov rax, 1              ; sys_write
    mov rdi, 1              ; stdout
    mov rsi, msg_prefix
    mov rdx, msg_prefix_len
    syscall
    
    ; ВОССТАНАВЛИВАЕМ результат после syscall
    pop rax
    
    ; Преобразуем число в строку и выводим
    mov edi, eax            ; Копируем eax в edi
    call print_number
    
    ; Выводим перенос строки
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Выход
    mov rax, 60
    xor rdi, rdi
    syscall

; Функция: находит максимум в массиве numbers
; Возвращает: eax = максимальное значение
find_max:
    mov eax, [numbers]      ; max = numbers[0]
    mov ecx, 1              ; i = 1

.loop:
    cmp ecx, len            ; Сравниваем текущий индекс с длиной массива
    jge .done               ; if (i >= len) goto done
    
    mov edx, [numbers + rcx*4]  ; edx = numbers[i]
    cmp edx, eax
    jle .skip               ; if (edx <= max) skip
    
    mov eax, edx            ; max = edx

.skip:
    inc ecx
    jmp .loop

.done:
    ret

; Функция: выводит число на экран
; Параметры: rdi = число для вывода (беззнаковое)
print_number:
    push rbp
    mov rbp, rsp
    push rbx
    
    ; Преобразуем число в строку (в обратном порядке)
    lea rsi, [digit_buffer + 19]
    mov byte [rsi], 0
    dec rsi
    
    mov rax, rdi
    mov rbx, 10

.convert_loop:
    xor rdx, rdx
    div rbx
    add dl, '0'
    mov [rsi], dl
    dec rsi
    
    test rax, rax
    jnz .convert_loop
    
    ; Вывод строки
    inc rsi
    lea rdx, [digit_buffer + 19]
    sub rdx, rsi
    
    mov rax, 1
    mov rdi, 1
    syscall
    
    pop rbx
    pop rbp
    ret

nasm -f elf64 max_print.asm -o max_print.o
ld max_print.o -o max_print
./max_print

Максимум: 91

❌ 7. Частые ошибки и их решения

При работе с массивами легко допустить ошибки, связанные с неправильной адресацией или несоответствием типов. Ниже рассмотрены самые типичные из них. Более подробный разбор и другие примеры вы найдёте в руководстве «Топ ошибок в NASM: Почему падает Segfault и неверные расчёты», а техники отладки описаны в статье «Отладка ASM в VS Code: Настройка GDB и визуальный интерфейс».

arr dw 10, 20, 30
mov ax, [arr + 2]    ; ❌ Получим arr[1], а не arr[2]!

arr db 1, 2, 3
mov al, [arr + 5]    ; ❌ Читаем случайные данные!

arr dw 1000
mov al, [arr]        ; ❌ al — 1 байт, потеряем данные!

arr dw 10, 20, 30
mov ax, [arr + 2*2]  ; ✅ arr[2] = 30
; или
mov rcx, 2
mov ax, [arr + rcx*2]

arr db 1, 2, 3
len equ $ - arr

mov rcx, 2           ; Индекс
cmp rcx, len
jge .out_of_bounds   ; ✅ Проверка перед доступом

mov al, [arr + rcx]

arr dw 1000
mov ax, [arr]        ; ✅ 16-битный регистр для dw

⚠️ Отладка: Если вы случайно вышли за границы массива, программа упадёт с ошибкой Segmentation fault. Как найти точное место ошибки с помощью GDB, описано в статье «Топ ошибок в NASM: Почему падает Segfault и неверные расчёты».

Дополнительные подводные камни

section .data
    arr db -1, -2, -3    ; Интерпретируется как 255, 254, 253

section .text
    mov al, [arr]
    cmp al, 0
    jl .negative         ; ❌ Не сработает! al = 255 (беззнаковое)

mov rsi, [arr]       ; Загружает ЗНАЧЕНИЕ первого элемента
lea rsi, [arr]       ; Загружает АДРЕС массива

💡 Шпаргалка по массивам