Регистры и перемещение данных
Обзор регистров
x86-64 имеет 16 регистров общего назначения 64-бит. Запись в 32-битный подрегистр (напр. eax) расширяет нулями старшие 32 бита полного регистра; запись в 16/8-битные подрегистры оставляет старшие биты без изменений.
; General-purpose 64-bit registers (x86-64)
; rax, rbx, rcx, rdx — main accumulators / scratch
; rsi, rdi — source/destination index (string ops)
; rbp, rsp — base pointer / stack pointer
; r8 .. r15 — extended registers
; 32-bit: eax, 32-bit: ecx, 16-bit: ax, 8-bit: al/ah
mov rax, 42 ; load immediate into 64-bit register
mov eax, 0x1F ; 32-bit move (zero-extends to rax)mov — перемещение данных
mov копирует данные между регистрами, памятью и непосредственными значениями. Перемещения память-в-память не разрешены — используйте регистр. Всегда указывайте размер (byte/word/dword/qword) при неоднозначности.
mov rax, 60 ; immediate -> register
mov rbx, rax ; register -> register
mov qword [rsp-8], 7 ; immediate -> memory (qword = 8 bytes)
mov rcx, [rsp-8] ; memory -> register
; INVALID: mov [rsp-8], [rsp-16] (memory-to-memory not allowed)
; Use two steps: mov rax, [src]; mov [dst], raxlea — загрузка эффективного адреса
lea вычисляет адрес операнда памяти без доступа к ней. Часто используется как быстрая арифметическая инструкция (умножение на 5/3/9 через масштаб+индекс) и для взятия адреса стековых переменных.
; Compute address without dereferencing
lea rax, [rbx + rcx*8 + 16] ; rax = rbx + rcx*8 + 16
; Common idiom: fast arithmetic (no memory access)
lea rax, [rax + rax*4] ; rax *= 5 (rax = rax + rax*4)
; Pointer into a buffer
lea rsi, [buffer] ; rsi = address of buffer
lea rdi, [rsp + 32] ; rdi = address of stack slotpush / pop — операции со стеком
push уменьшает rsp на 8 и сохраняет значение; pop загружает и увеличивает rsp. В ABI System V AMD64 первые 6 целочисленных аргументов передаются в rdi, rsi, rdx, rcx, r8, r9 — push в основном для сохранения callee-saved регистров (rbx, rbp, r12-r15).
push rax ; rsp -= 8; [rsp] = rax
push qword 42 ; push immediate
pop rbx ; rbx = [rsp]; rsp += 8
; Save/restore callee-saved registers
push rbx
push r12
; ... function body ...
pop r12
pop rbx
ret
; Push arguments in reverse (C calling convention)
push 3
push 2
push 1xchg / xadd — атомарный обмен
xchg с операндом памяти всегда атомарен (неявная блокировка). xadd совмещает обмен и сложение. Вместе с lock cmpxchg они образуют основу примитивов синхронизации без блокировок.
; xchg swaps two operands (implicitly LOCKed with memory)
xchg rax, rbx ; swap register/register
xchg [counter], rcx ; swap memory/register (atomic)
; xadd: swap then add (returns old value in src)
; lock xadd [counter], rax ; atomic fetch-and-add
; Spinlock idiom
spin:
xor eax, eax
lock cmpxchg [lock_var], 1 ; if [lock_var]==0, set to 1
jnz spin ; retry if not acquiredmovzx / movsx — расширение нулём/знаком
movzx расширяет нулём меньшее значение в больший регистр (беззнаковая загрузка). movsx расширяет знаком. Используйте movsxd для загрузки 32-битного значения со знаком в 64-битный регистр.
; movzx: zero-extend (unsigned)
movzx rax, byte [rsi] ; load byte, zero-extend to 64-bit
movzx eax, word [rdi] ; load word, zero-extend to 32-bit
; movsx: sign-extend (signed)
movsx rax, byte [rsi] ; sign-extend byte to 64-bit
movsx rax, dword [rdi] ; sign-extend 32-bit to 64-bit (movsxd)Арифметика и логика
add / sub — целочисленная арифметика
add/sub устанавливают CF, OF, SF, ZF, PF и AF. Используйте jc/jo для обнаружения беззнакового/знакового переполнения. Вычитание из rsp выделяет стековое пространство — держите rsp выровненным по 16 байт перед вызовами согласно ABI.
add rax, rbx ; rax = rax + rbx
add rax, 10 ; rax = rax + 10
sub rcx, rdx ; rcx = rcx - rdx
sub rsp, 32 ; allocate 32 bytes of stack (align!)
; 64-bit addition with carry check
add rax, rbx
jc .overflow ; jump if unsigned overflow (CF=1)imul / idiv — умножение и деление
Двухоперандный imul — обычная форма, хранит только младшие 64 бита. Для умножения полной ширины используйте однооперандный mul/imul (результат в rdx:rax). Перед idiv расширьте знак делимого через cqo.
; Two-operand imul (most common): dst = dst * src
imul rax, rbx ; rax = rax * rbx (lower 64 bits)
imul rcx, 10 ; rcx = rcx * 10
; One-operand: rdx:rax = rax * src (full 128-bit)
mul rbx ; unsigned: rdx:rax = rax * rbx
imul rbx ; signed: rdx:rax = rax * rbx
; idiv: signed divide rdx:rax by src
; Must sign-extend rax into rdx:rax first!
cqo ; sign-extend rax -> rdx:rax
idiv rcx ; rax = rdx:rax / rcx, rdx = remainder
; Unsigned: use div (zero rdx first)
xor rdx, rdx
div rcx ; rax = rdx:rax / rcx, rdx = remainderinc / dec / neg
inc и dec НЕ обновляют флаг переноса (CF) — это позволяет использовать их в цепочках многоточного сложения/вычитания. Они обновляют ZF/SF/OF. neg вычисляет отрицание в дополнительном коде и ставит CF=1, если операнд не 0.
inc rax ; rax++ (does NOT affect CF!)
dec rcx ; rcx-- (does NOT affect CF!)
neg rdx ; rdx = -rdx (two's complement negate)
; Common loop pattern
mov rcx, 10
.loop:
; ... loop body ...
dec rcx
jnz .loop ; repeat until rcx == 0and / or / xor / not / test
xor reg,reg — идиоматичный способ обнулить регистр (короче чем mov reg,0). test a,a эквивалентен and a,a, но отбрасывает результат. and/or/xor очищают CF и OF.
and rax, 0xFF ; mask low byte (rax &= 0xFF)
or rcx, 0x10 ; set bit 4
xor rdx, rdx ; rdx = 0 (idiomatic zeroing)
xor rax, rax ; clear rax (shorter than mov rax,0)
not r8 ; bitwise NOT (one's complement)
test rax, rax ; set flags from rax & rax (checks zero/sign)
test rcx, 0x1 ; test if low bit set (odd/even check)shl / shr / sar — сдвиги
shl/shr — логические сдвиги (заполнение нулями); sar сохраняет знаковый бит (арифметический). Умножение/деление на степени двойки сдвигами намного быстрее imul/idiv. Счётчик маскируется до 5 или 6 бит.
shl rax, 4 ; logical left shift (rax *= 16)
shr rax, 3 ; logical right shift (unsigned rax /= 8)
sar rax, 3 ; arithmetic right shift (signed rax /= 8)
; Rotate (carry not involved)
rol rax, 4 ; rotate left
ror rax, 4 ; rotate right
; Shift by CL (only low 5 bits used in 64-bit mode)
mov cl, 4
shl rax, cl ; shift left by 4Поток управления и ветвление
cmp / test — сравнение
cmp устанавливает флаги как вычитание без сохранения. Для знаковых сравнений используйте je/jne/jl/jg/jle/jge; беззнаковых — jb/ja/jbe/jae. Их путаница — классический баг: jl проверяет SF!=OF, а jb — CF.
cmp rax, rbx ; compute rax - rbx, set flags (discard result)
cmp rax, 10 ; compare with immediate
; Signed comparisons
cmp rax, rbx
je .equal ; jump if rax == rbx (ZF=1)
jl .less ; jump if rax < rbx signed (SF!=OF)
jg .greater ; jump if rax > rbx signed (ZF=0 and SF==OF)
jle .le ; jump if rax <= rbx signed
jge .ge ; jump if rax >= rbx signed
; Unsigned comparisons (use 'below'/'above' mnemonics)
cmp rax, rbx
jb .below ; rax < rbx unsigned (CF=1)
ja .above ; rax > rbx unsigned (CF=0 and ZF=0)
jbe .be ; rax <= rbx unsigned
jae .ae ; rax >= rbx unsignedjmp — безусловный переход
jmp выполняет безусловный переход. Условные переходы (jcc) проверяют флаги, установленные cmp/test/арифметикой. В 64-битном режиме ближние условные переходы достигают ±2 ГБ. Косвенные переходы позволяют таблицы switch/case.
; Direct jump to a label
jmp .end
; Conditional jumps (short/near, 64-bit allows near)
.loop:
dec rcx
jnz .loop ; jump if ZF=0 (rcx != 0)
; Indirect jump through register/memory (jump table)
lea rax, [table]
mov rdi, [rax + rbx*8]
jmp rdi ; jump to address in rdi
; Jump table example (switch statement)
table: dq .case0, .case1, .case2, .case3Общие условные переходы
Есть много синонимов (je==jz, jb==jc==jnae). Различие знаковых (l/g) и беззнаковых (b/a) критично: jl/jg проверяют SF и OF; jb/ja — CF. Используйте знаковые формы после сравнения знаковых целых.
; After cmp/test:
je / jz ; jump if equal / zero (ZF=1)
jne / jnz ; jump if not equal / nonzero (ZF=0)
; Signed
jl / jnge ; less (SF!=OF)
jge / jnl ; greater-or-equal (SF==OF)
jle / jng ; less-or-equal (ZF=1 or SF!=OF)
jg / jnle ; greater (ZF=0 and SF==OF)
; Unsigned
jb / jnae / jc ; below / carry (CF=1)
jae / jnb / jnc ; above-or-equal (CF=0)
jbe / jna ; below-or-equal (CF=1 or ZF=1)
ja / jnbe ; above (CF=0 and ZF=0)
; Special
js ; jump if sign (SF=1)
jns ; jump if not sign (SF=0)
jo ; jump if overflow (OF=1)
jno ; jump if no overflow (OF=0)Цикл с loop
loop уменьшает rcx и переходит, если rcx!=0. Хотя удобен, на современных CPU медленнее пары dec/jnz, поэтому компиляторы генерируют dec/jnz.
; loop: dec rcx then jump if rcx != 0
mov rcx, 5
.loop:
; ... body executes 5 times ...
loop .loop
; loope/loopz: loop while equal/zero
; loopne/loopnz: loop while not equal/not zero
; Modern compilers prefer dec + jnz (loop is slower on many CPUs)
mov rcx, 5
.loop:
; ...
dec rcx
jnz .loopcmov — усл овное перемещение
cmovcc выполняет условное перемещение — код без ветвлений, избегающий штрафов за неверное предсказание. Приёмник должен быть регистром. cmov всегда вычисляет оба источника, избегайте при побочных эффектах.
; cmovcc: move only if condition is true (branchless)
cmp rax, rbx
cmovl rax, rbx ; if rax < rbx (signed), rax = rbx -> rax = min(a,b)
; max(a, b)
cmp rax, rbx
cmovl rax, rbx ; rax = max(rax, rbx)? No: if rax<rbx, set rax=rbx -> max
; Branchless abs:
; abs(x): mask = x >> 63; result = (x ^ mask) - mask
mov rax, rdi
sar rdi, 63 ; all 1s if negative, 0 if positive
xor rax, rdi
sub rax, rdi ; rax = |original rdi|Стек, функции и соглашение о вызовах
Пролог и эпилог функции
Стандартный пролог сохраняет rbp, устанавливает его как указатель кадра и выделяет локальные переменные вычитанием из rsp. leave — однобайтовый эпилог, эквивалент mov rsp,rbp; pop rbp. ABI System V AMD64 требует выравнивание rsp по 16 байт в точке вызова.
; System V AMD64 calling convention (Linux/macOS)
; Args: rdi, rsi, rdx, rcx, r8, r9 (then stack)
; Return: rax. Callee-saved: rbx, rbp, r12-r15
my_func:
push rbp
mov rbp, rsp ; standard prologue
sub rsp, 32 ; allocate locals (keep 16-byte aligned)
; ... function body ...
mov rsp, rbp ; or: leave
pop rbp ; standard epilogue
ret
; Compact form using leave
my_func2:
push rbp
mov rbp, rsp
sub rsp, 16
; ...
leave ; mov rsp,rbp; pop rbp
retcall / ret — вызов и возврат
call помещает адрес возврата (8 байт в 64-бит) в стек и переходит к цели; ret извлекает его в rip. Для хвостовых вызовов используйте jmp, чтобы вызываемый вернулся напрямую к вашему вызывающему — это сохраняет стек и включает оптимизацию хвостовых вызовов.
; call pushes return address, then jumps
call my_func
; ret pops return address into rip
my_func:
; ...
ret
; Call with arguments (System V AMD64)
mov rdi, 1 ; 1st arg
mov rsi, 2 ; 2nd arg
mov rdx, 3 ; 3rd arg
call add_three ; result in rax
; Tail call: jmp instead of call+ret
my_wrapper:
jmp target_func ; reuses our return addressЛистовые функции и красная зона
ABI System V AMD64 резервирует «красную зону» 128 байт под rsp, которую листовые функции (без вызовов) могут использовать без корректировки rsp. В Windows x64 НЕТ красной зоны. Листовым функциям часто пролог не нужен.
; Leaf function (no calls) can use the red zone:
; 128 bytes below rsp that won't be clobbered by signals/interrupts
leaf_sqrt_sum:
; rdi, rsi = args, rax = result
mov rax, rdi
add rax, rsi
ret ; no prologue needed!
; Non-leaf functions MUST save rsp properly because
; a call would write into the red zone.
; Red zone is NOT honored on Windows x64.Локальные переменные и кадр стека
С указателем кадра (rbp) локальные переменные доступны через [rbp - offset], а аргументы стека через [rbp + offset]. Компиляторы часто опускают указатель кадра и обращаются к локальным напрямую через rsp.
my_func:
push rbp
mov rbp, rsp
sub rsp, 32 ; 32 bytes for locals
; Local variables accessed via [rbp - offset]
mov qword [rbp-8], 10 ; local1
mov qword [rbp-16], 20 ; local2
; Read arguments (also via rbp once saved on stack,
; or directly from registers)
mov rax, [rbp-8]
add rax, [rbp-16]
leave
retСохранение callee-saved регистров
Callee-saved регистры (rbx, rbp, r12-r15) должны сохраняться — push при входе, pop в обратном порядке при выходе. Caller-saved (rax, rcx, rdx, rsi, rdi, r8-r11) можно свободно менять, но сохраняйте их при необходимости между вызовами.
; rbx, rbp, r12, r13, r14, r15 are callee-saved
; rax, rcx, rdx, rsi, rdi, r8-r11 are caller-saved
my_func:
push rbx ; we want to use rbx
push r12 ; and r12
mov rbx, rdi ; use them
mov r12, rsi
; ... do work, may call other functions ...
; (those calls will preserve rbx/r12 for us)
mov rax, rbx ; prepare return value
pop r12 ; restore in REVERSE order
pop rbx
retСистемные вызовы и Hello World
syscall — системный вызов Linux
В Linux x86-64 системные вызовы используют инструкцию syscall с номером в rax и до 6 аргументов в rdi, rsi, rdx, r10, r8, r9 (r10, не rcx, для 4-го аргумента!). Частые номера: write=1, read=0, exit=60, mmap=9. syscall разрушает rcx и r11.
; Linux x86-64 syscall convention:
; rax = syscall number
; rdi, rsi, rdx, r10, r8, r9 = args (NOTE: r10 not rcx!)
; return value in rax; clobbers rcx and r11
; write(1, msg, 12)
mov rax, 1 ; syscall: write
mov rdi, 1 ; fd = stdout
lea rsi, [msg] ; buf
mov rdx, 12 ; count
syscall
; exit(0)
mov rax, 60 ; syscall: exit
xor rdi, rdi ; status = 0
syscall
section .data
msg: db "hello world", 10 ; 12 bytes with newlineПолный Hello World (NASM, Linux)
Автономный hello world не линкуется с libc — вызывает ядро напрямую через syscall. $ - msg вычисляет длину во время ассемблирования. _start — точка входа ld по умолчанию. Программа завершается системным вызовом exit.
; nasm -f elf64 hello.asm && ld hello.o -o hello && ./hello
section .data
msg: db "Hello, World!", 10
msg_len: equ $ - msg ; length computed at assemble time
section .text
global _start
_start:
; write(1, msg, msg_len)
mov rax, 1 ; write
mov rdi, 1 ; stdout
mov rsi, msg
mov rdx, msg_len
syscall
; exit(0)
mov rax, 60
xor rdi, rdi
syscallЧтение argc / argv командной строки
При входе в _start (Linux, без libc) ядро помещает argc в [rsp], затем указатели argv, envp и NULL. Если линкуетесь с libc и используете main, C-рантайм парсит их — main получает argc и argv в rdi/rsi.
; At _start the stack looks like:
; [rsp] = argc
; [rsp+8] = argv[0]
; [rsp+16] = argv[1]
; ...
; [rsp + 8*(argc+1)] = NULL
_start:
mov rdi, [rsp] ; argc
mov rsi, [rsp+8] ; argv[0] (program name)
mov rdx, [rsp+16] ; argv[1] (first user arg)
; Loop over argv
mov rbx, rsp
add rbx, 8 ; skip argc, point at argv[0]
.loop:
mov rax, [rbx]
test rax, rax
jz .done ; NULL terminator
; rax -> one argv string
add rbx, 8
jmp .loop
.done:
; exit
mov rax, 60
xor rdi, rdi
syscallВызов функций библиотеки C
При вызове C-функций выровняйте rsp по 16 байт перед call. Для вариативных функций вроде printf rax должен содержать количество векторных (XMM) аргументов — установите 0 для вызовов только с целыми. Используйте main как точку входа.
; Link with gcc: nasm -f elf64 demo.asm && gcc demo.o -o demo -no-pie
extern printf
section .data
fmt: db "sum = %d", 10, 0
section .text
global main
main:
push rbp
mov rbp, rsp
sub rsp, 16 ; keep stack 16-byte aligned
; printf("sum = %d\n", 42)
; Variadic: rdi=fmt, rsi=arg, rax=#vector regs (0)
lea rdi, [fmt]
mov rsi, 42
xor rax, rax ; 0 floating-point args
call printf
xor rax, rax ; return 0
leave
retСвязанные сниппеты Assembly
Copy-paste ready code for common tasks.
Hello World через syscall Linux
Автономная x86-64 программа, выводящая и завершающаяся только системными вызовами ядра.
Соглашение о вызове функций (System V AMD64)
Аргументы в регистрах, сохранение callee-saved регистров, выравнивание rsp по 16 байтам.
Сумма в цикле (1..N)
Сумма целых 1..N счётным циклом через dec/jnz.
strlen — сканирование до NUL
Вычисление длины C-строки сканированием памяти до нулевого байта.
memcpy — копирование через rep movsb
Компактное копирование памяти строковой инструкцией rep movsb.
Битовые операции: popcount, ctz, abs
Безветвленные битовые операции через инструкции BMI/ABM.
Чтение файла через syscalls
open/read/write/close файла только системными вызовами Linux.
Рекурсивный факториал
Рекурсивная реализация factorial(n) с корректным стековым кадром.
Было ли это полезно?