АСЕМБЛЕР x86-64

Вступ: навіщо системному програмісту машинна мова

Коли компілятор перетворює вираз a + b на трибуквені мнемоніки mov, add, ret, він не винаходить нову мову — він перекладає намір програміста на єдину мову, яку фізично розуміє кристал кремнію: набір інструкцій x86-64 (розширення 64-бітної адресації набору x86, відоме також як AMD64 чи Intel 64). У цій лекції ми не вчимося писати великі програми асемблером (assembler) — це неефективно й у 2026 році майже ніколи не потрібно, — а вчимося його читати: розбирати вивід gcc -S, objdump -d, розуміти, що саме бачить процесор, коли виконує вашу функцію.

Це фундамент, без якого незрозуміло:

• чому одні оптимізації компілятора взагалі можливі, а інші — ні;
• чому переповнення стека (stack overflow, use-after-return) — реальна, а не абстрактна загроза;
• чому в Rust unsafe-блок здатний зламати гарантії, які Rust дає в безпечному коді (Модуль 2);
• і чому WebAssembly (Лекція 9) взагалі існує — це теж набір інструкцій, тільки для іншої, віртуальної машини, і порівнювати їх можна лише розуміючи обидва.

Асемблер — не «низький рівень заради складності». Це пряме, майже без втрат, відображення того, що фізично вміє робити процесор: перекласти число з одного місця в інше, додати, порівняти, стрибнути за умовою.

Регістри x86-64: анатомія

Регістр (register) — це комірка пам'яті всередині самого процесора, читання й запис у яку не потребують звернення до шини пам'яті і тому займають один такт (або й менше — сучасні ядра виконують кілька інструкцій за такт). x86-64 має 16 регістрів загального призначення по 64 біти кожен. Молодші розряди того самого фізичного регістра доступні під окремими іменами — спадок від 16-бітного 8086 і 32-бітного i386, збережений заради сумісності:

Окремо стоїть rip (instruction pointer) — адреса наступної інструкції; його не можна записати інструкцією mov, лише непрямо через jmp, call чи ret. Важливо розуміти: запис у 32-бітну частину регістра (eax) обнуляє верхні 32 біти 64-бітного регістра (rax), а от запис у 16- чи 8-бітну частину (ax, al) верхні біти не чіпає — це джерело неочевидних багів, коли в 64-бітному регістрі лишається «сміття» від попереднього обчислення.

Синтаксис: AT&T проти Intel

Одна й та сама інструкція записується по-різному залежно від традиції інструментарію:

Обидва синтаксиси описують той самий фізичний код — це питання нотації, а не семантики. У курсі ми читаємо вивід gcc -S та objdump -d (AT&T за замовчуванням), а пишемо руками — в NASM (Intel). Найпоширеніша помилка новачків — переплутати напрямок операндів при переході між ними; правило: в AT&T читай справа наліво, в Intel — зліва направо, і в обох випадках приймач опиниться на «своєму» боці.

Стек і кадр функції

Стек — це ділянка пам'яті процесу, що росте вниз: кожен push зменшує rsp на розмір значення (зазвичай 8 байтів на x86-64) і записує значення за новою адресою; pop робить навпаки. Кожен виклик функції створює на стеку свій кадр (stack frame) — «робочий стіл», на якому лежать збережений rbp викликача, локальні змінні й місце для аргументів, що не влізли в регістри.

Класичний пролог і епілог:

func:
    pushq   %rbp        ; зберегти кадр викликача
    movq    %rsp, %rbp  ; rbp = початок нового кадру
    ; ... тіло, звертання через -N(%rbp) ...
    popq    %rbp        ; повернути кадр викликача
    ret                 ; зняти адресу повернення й стрибнути туди

call неявно заштовхує на стек адресу наступної інструкції (адресу повернення), а ret її знімає — тому кожному call має відповідати рівно один ret, інакше стек «з'їжджає» і функція поверне керування в довільне місце пам'яті.

System V AMD64 ABI: контракт виклику

ABI (Application Binary Interface) — угода на рівні байтів, без якої окремо скомпільовані .o-файли не змогли б викликати одне одного, навіть якщо написані різними компіляторами. Для Linux/macOS x86-64 діє System V AMD64 ABI:

Результат повертається в rax (ціле/вказівник, до 64 біт; для 128-бітних значень — пара rax:rdx) або xmm0 (float/double). Регістри діляться на дві групи за тим, хто відповідає за їхнє збереження:

• callee-saved (rbx, rbp, rsp, r12–r15): якщо функція їх використовує, вона зобов'язана зберегти й відновити значення до виходу — інакше зламає викликача;
• caller-saved (rax, rcx, rdx, rsi, rdi, r8–r11): викликач не може розраховувати, що їхній вміст переживе виклик, і має сам зберегти потрібне до call, якщо воно знадобиться після.

Стек перед кожним call повинен бути вирівняний на 16 байтів (rsp % 16 == 0 у момент виклику) — вимога SSE-інструкцій, які компілятор використовує для роботи з float/double; порушення вирівнювання — джерело важких для діагностики крашів саме в released-збірках, де SSE активно застосовується.

Прапорці й умовні переходи

Немає окремої машинної інструкції «if». Натомість cmp a, b обчислює a - b, відкидає результат, але виставляє біти регістра rflags:

• ZF (zero flag) — результат нульовий (a == b);
• SF (sign flag) — результат від'ємний;
• CF (carry flag) — було безнакове перенесення/позика;
• OF (overflow flag) — знакове переповнення.

Умовні переходи (jcc) читають комбінацію цих прапорців:

Плутанина знакових (jl/jg) із беззнаковими (jb/ja) варіантами — типова причина логічних багів, коли, наприклад, порівнюють size_t як знакове число і від'ємний результат «загортається» у величезне беззнакове.

Адресація пам'яті

Загальна форма операнда пам'яті: зсув(база, індекс, масштаб), що обчислюється як адреса = база + індекс*масштаб + зсув. Саме так компілятор реалізує доступ до елемента масиву a[i] за один такт адресної арифметики: (%rbx, %rax, 4) означає «база rbx, індекс rax, масштаб 4» — прямий аналог int-масиву. Ця ж ідея — «базова адреса плюс зсув» — повернеться в Лекції 9 як модель лінійної пам'яті WebAssembly, тільки замість регістра-бази там буде єдина, спільна для всього модуля область байтів.

NASM: коли асемблер пишуть руками

gcc -S показує, що згенерував компілятор; NASM (Netwide Assembler) — інструмент, яким асемблер пишуть, коли потрібна ділянка коду поза досяжністю компілятора (примітиви ОС, крос-мовні бібліотеки, навчальні вправи на кшталт наших). NASM використовує синтаксис Intel, і файл ділиться на секції:

section .text          ; виконуваний код
    global add          ; зробити символ 'add' видимим для лінкера

add:
    mov     eax, edi     ; перший аргумент (int) прийшов у edi
    add     eax, esi     ; додати другий аргумент (esi)
    ret                  ; результат уже в eax — угода ABI дотримана

Асемблювання й компонування — два окремі кроки:

nasm -f elf64 add.asm -o add.o     # текст → об'єктний файл (формат ELF64)
gcc main.c add.o -o app            # лінкер зшиває .o з рештою програми
./app

Символ add, оголошений global, стає видимим лінкеру так само, як звичайна C-функція — саме тому NASM-код можна викликати з C напряму, без жодної обгортки, якщо він дотримується System V AMD64 ABI: параметри в rdi/rsi/…, результат у rax, збережені callee-saved регістри. З боку C оголошення виглядає як звичайний прототип:

extern int add(int a, int b);   /* реалізація — у add.asm */

int main(void) {
    return add(2, 3);
}

Компілятор C не генерує для extern-функції жодного коду — лише довіряє лінкеру знайти символ з тим самим іменем. Це та сама угода, завдяки якій libc, написана здебільшого на C, безшовно викликає системні виклики, реалізовані асемблерними вставками в ядрі.

Підводні камені

• Наплутати напрямок операндів між AT&T (mov src, dst) та Intel (mov dst, src) — найчастіша помилка новачків при читанні чужого коду.
• Порушити вирівнювання стека на 16 байтів перед call — SSE-інструкції (робота з float/double) у такому разі падають з SIGSEGV лише в оптимізованій збірці, де компілятор дозволяє собі їх використовувати.
• Записати в 16/8-бітну частину регістра, розраховуючи, що верхні біти обнулилися — на відміну від 32-бітного запису, вони не обнуляються, і в 64-бітному регістрі лишається «сміття».
• Переплутати знакові й беззнакові умовні переходи (jl замість jb) — критично при порівнянні розмірів (size_t), де від'ємне число «загортається» у величезне додатне.
• Забути парність call/ret — ручний push без відповідного pop у тілі функції зсуває адресу повернення, і ret передає керування в довільне місце.
• Ігнорувати red zone — 128 байтів нижче rsp, які «листові» функції (без власних викликів) можуть використовувати без явного зменшення rsp; але цей простір непридатний усередині обробників сигналів, які можуть перезаписати його асинхронно.

Підсумок

Асемблер x86-64 — це не окрема «мова програмування» для написання застосунків, а словник, яким компілятор і процесор домовляються між собою. Регістри — обмежена, фізично існуюча кількість «змінних»; стек — дисципліноване використання пам'яті для кадрів викликів; ABI — контракт, без якого окремо скомпільовані файли не могли б співпрацювати; прапорці й jcc — весь механізм, з якого складені if і цикли будь-якої мови вищого рівня. Уміння читати цей рівень — не самоціль, а інструмент: коли Лекція 9 покаже WebAssembly, ви побачите ту саму задачу (виконати обчислення на реальному чи віртуальному процесорі), розв'язану інакше — без регістрів, зате переносно.