Assembly x86/x64 Cheatsheet

1. Matriks Register Intel x86 (32-bit) vs AMD64 (64-bit)

Register 64-bit dapat diakses bagian-bagiannya yang lebih kecil (32-bit, 16-bit, 8-bit tinggi & rendah):

64-bit (8B)	32-bit (4B)	16-bit (2B)	8-bit Low	Fungsi Konvensional & Karakteristik
`RAX`	`EAX`	`AX`	`AL` (`AH`: byte tinggi)	Accumulator: Menyimpan return value fungsi, operasi aritmetika & I/O.
`RBX`	`EBX`	`BX`	`BL` (`BH`)	Base Register: Pointer ke data di segmen DS, callee-saved.
`RCX`	`ECX`	`CX`	`CL` (`CH`)	Counter: Pengendali loop counter (LOOP), shift counts, argumen ke-4 (Linux) / ke-1 (Win x64).
`RDX`	`EDX`	`DX`	`DL` (`DH`)	Data Register: Operasi perkalian/pembagian 64/128-bit, argumen ke-3 (Linux) / ke-2 (Win x64).
`RSI`	`ESI`	`SI`	`SIL`	Source Index: Sumber operasi string/array, argumen ke-2 fungsi di Linux x64.
`RDI`	`EDI`	`DI`	`DIL`	Destination Index: Tujuan operasi string, argumen ke-1 fungsi di Linux x64.
`RBP`	`EBP`	`BP`	`BPL`	Base / Frame Pointer: Titik referensi tetap untuk local variables dan argumen stack.
`RSP`	`ESP`	`SP`	`SPL`	Stack Pointer: Menunjuk ke posisi paling atas (top) memori stack saat ini.
`RIP`	`EIP`	`IP`	-	Instruction Pointer: Menyimpan alamat memori instruksi CPU berikutnya yang akan dieksekusi.
`R8 - R15`	`R8D - R15D`	`R8W - R15W`	`R8B - R15B`	Register umum tambahan eksklusif pada mode 64-bit. (R8=arg 5, R9=arg 6 pada System V).

2. Katalog Instruksi Assembly Fundamental

A. Transfer Data & Manipulasi Alamat

Instruksi	Sintaks Contoh	Penjelasan Operasi & Efek ke C
`MOV`	`mov eax, [rbp-4]`	Salin nilai operand sumber ke operand tujuan. `eax = a;`
`MOVZX`	`movzx eax, al`	Move with Zero-Extend: mengisikan 0 ke bit-bit atas saat transfer dari tipe kecil ke besar (misal `unsigned char` ke `int`).
`MOVSX`	`movsx eax, al`	Move with Sign-Extend: memperluas bit tanda saat transfer bilangan bertanda (misal `signed char` ke `int`).
`LEA`	`lea rax, [rbp-8]` `lea eax, [rdi+rsi*4]`	Load Effective Address: Menghitung alamat memori tanpa mengakses memori itu sendiri! Sering dipakai compiler untuk trik aritmetika cepat (misal `a + b*4`) atau pointer address `&x`.
`PUSH`	`push rbp`	Kurangi RSP (RSP -= 8), lalu simpan nilai ke memori `[RSP]`.
`POP`	`pop rbp`	Ambil nilai dari `[RSP]` ke tujuan, lalu tambah RSP (RSP += 8).

B. Aritmetika & Logika Bit

Instruksi	Sintaks Contoh	Operasi C Terkait
`ADD / SUB`	`add eax, 5` / `sub eax, 2`	`eax += 5;` / `eax -= 2;`
`INC / DEC`	`inc eax` / `dec ecx`	`eax++;` / `ecx--;`
`IMUL`	`imul eax, edx` `imul eax, [rbp-4], 10`	Signed multiplication. Bentuk 3 operand: `eax = var * 10;`
`IDIV`	`cdq; idiv ecx`	Signed division: EDX:EAX dibagi ECX. Hasil bagi di `EAX` (quotient /), sisa di `EDX` (modulo %).
`AND / OR / XOR`	`xor eax, eax` `and eax, 0x0F`	Operasi bitwise: `xor reg, reg` adalah cara standar compiler untuk `reg = 0;` karena paling efisien opcode-nya.
`SHL / SHR`	`shl eax, 2` / `shr eax, 1`	Bit shift: `eax << 2` (kali 4) dan logical right shift `eax >> 1` (bagi 2 unsigned).
`SAR`	`sar eax, 1`	Arithmetic right shift: menggeser bit ke kanan dengan mempertahankan bit sign (bagi 2 signed).
`NOT / NEG`	`not eax` / `neg eax`	Bitwise NOT `~a` / Two's complement negation `-a`.

C. Kontrol Alur & Jump Berdasarkan Flag

Prinsip Flag CMP & TEST

cmp a, b melakukan operasi internal a - b dan mengatur RFLAGS (ZF: Zero Flag, SF: Sign Flag, OF: Overflow Flag, CF: Carry Flag) tanpa mengubah nilai a.

test a, b melakukan operasi internal bitwise a & b dan mengatur ZF. Umum dipakai untuk memeriksa nilai 0: test eax, eax; jz .IS_ZERO.

Instruksi	Kondisi Flag	Artian & Hubungan Logika C
`JMP`	Unconditional	Lompat mutlak: `goto label;` atau loop continuation.
`JE / JZ`	ZF = 1	Jump if Equal / Jump if Zero: `if (a == b)` atau `if (x == 0)`.
`JNE / JNZ`	ZF = 0	Jump if Not Equal / Not Zero: `if (a != b)`.
`JG / JNLE`	ZF = 0 and SF = OF	Jump if Greater (Signed): `if (a > b)`.
`JGE / JNL`	SF = OF	Jump if Greater or Equal (Signed): `if (a >= b)`.
`JL / JNGE`	SF != OF	Jump if Less (Signed): `if (a < b)`.
`JLE / JNG`	ZF = 1 or SF != OF	Jump if Less or Equal (Signed): `if (a <= b)`.
`JA / JB`	CF = 0 / CF = 1	Jump if Above / Jump if Below (Unsigned comparison).

3. Calling Conventions (Konvensi Pemanggilan Fungsi)

cdecl (Standar Linux & C 32-bit)

Lokasi Argumen: Semua parameter dilewatkan melalui Stack dalam urutan kanan ke kiri (right-to-left).
Stack Cleanup: Tanggung jawab Caller (pemanggil) membersihkan stack setelah call (misal: add esp, 8).
Return Value: Disimpan dalam register EAX (atau EDX:EAX untuk 64-bit int).

System V AMD64 ABI (Linux x64)

6 Argumen Pertama via Register:
1: RDI, 2: RSI, 3: RDX, 4: RCX, 5: R8, 6: R9.
Argumen ke-7 dst: Dilewatkan melalui stack.
Return Value: Disimpan di RAX.
Floating Point: Menggunakan register XMM0 - XMM7.

Microsoft x64 Calling Convention (Windows x64)

Menggunakan 4 register: 1: RCX, 2: RDX, 3: R8, 4: R9. Caller wajib mengalokasikan 32 bytes "Shadow Space" (Home Space) di stack sebelum instruksi call.

4. Anatomi Stack Frame Memori (RBP / EBP Layout)

Memori stack bergerak dari alamat memori TINGGI ke alamat memori RENDAH. Variabel lokal diakses dengan offset negatif dari base pointer (rbp - offset), sedangkan argumen fungsi (pada 32-bit) diakses dengan offset positif (ebp + offset).

Alamat Relatif	Tipe Isi	Keterangan Fungsi
`[rbp + 16]`	Argumen ke-2 (32-bit cdecl)	Parameter fungsi pemanggil
`[rbp + 12]`	Argumen ke-1 (32-bit cdecl)	Parameter fungsi pemanggil
`[rbp + 8]`	Return Address (Saved RIP/EIP)	Alamat instruksi berikutnya setelah fungsi selesai dieksekusi (disimpan otomatis oleh CALL)
`[rbp]`	Saved Frame Pointer (Old RBP/EBP)	Titik tumpu frame saat ini (disimpan saat `push rbp`)
`[rbp - 4]`	Variabel Lokal 1 (4 bytes int)	Contoh: `int a;`
`[rbp - 8]`	Variabel Lokal 2 (4 bytes int)	Contoh: `int b;`
`[rbp - 16]`	Array / Buffer / Padding	Alokasi alignment 16-byte CPU
`[rsp]`	Top of Stack	Posisi terkini stack pointer setelah alokasi `sub rsp, N`