Belajar Assembly - Register, Data Types & Addressing

#Pendahuluan

Setelah menguasai dua dialek sintaks di episode 4, sekarang kita bedah bahan bakunya: register, tipe data, dan cara CPU mengakses memori. Ketiganya adalah "kosakata" yang membentuk hampir semua instruksi. Tanpa pemahaman ini, kalian hanya akan menghafal contoh — dengan pemahaman ini, kalian mulai berpikir seperti CPU.

Bayangkan register sebagai kotak penyimpanan di meja kerja: ada yang 64-bit besar (qword), ada yang 32-bit, ada yang cuma 1 byte. Memahami register mana yang menyentuh bagian mana dari register lain adalah kunci membaca kode assembly apa pun dengan cepat.

#Register General-Purpose x86-64

x86-64 punya 16 register general-purpose 64-bit: rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp, dan r8–r15. Masing-masing bisa diakses utuh (64-bit) atau sebagian (32/16/8 bit):

#Peran Khusus (Konvensi ABI)

Beberapa register punya peran konvensional yang dipakai sistem operasi dan compiler — kita bedah lengkap saat membahas ABI di episode 9:

• rax — hasil return fungsi, dan nomor syscall.
• rdi, rsi, rdx, rcx, r8, r9 — argumen fungsi (System V).
• rsp — stack pointer.
• rbp — base pointer (frame pointer).
• rcx — counter untuk loop/shift.

#RIP dan RFLAGS

RIP (Instruction Pointer) menunjuk instruksi berikutnya yang akan dieksekusi — diperkenalkan di episode 2. Kalian tidak bisa menulis ke RIP secara langsung, hanya lewat jmp/call/ret.

RFLAGS adalah register 64-bit berisi flag status. Lima flag yang paling penting bagi kita:

Flag inilah "otak" dari conditional jump (je, jg, dst) di episode 6:

mov rax, 5
sub rax, 5     ; hasil 0 → ZF = 1
sub rax, 1     ; hasil -1 → SF = 1, ZF = 0

#Tipe Data di NASM

NASM mendeklarasikan data dengan direktif berikut:

Contoh penggunaan nyata:

section .data
    byte_val   db 0x41, 0x42, 0x43        ; 3 byte: 'A' 'B' 'C'
    word_val   dw 0x1234                  ; 2 byte
    dword_val  dd 1000000                 ; 4 byte
    qword_val  dq 0x1122334455667788      ; 8 byte
    float32    dd 3.14                    ; single precision
    float64    dq 2.718281828             ; double precision
    str_null   db "hello", 0              ; string null-terminated
    repeat10   times 10 db 0              ; 10 byte nol

times adalah perkalian deklarasi — berguna sekali untuk array dan buffer, dan kita pakai lagi di episode 11 dan 13.

#Addressing Modes: Lima Cara Mengakses Data

Ini adalah inti episode ini. "Addressing mode" menjawab pertanyaan: di mana operan berada? CPU x86-64 mendukung lima mode utama:

#1. Immediate

Nilai ditanam langsung di instruksi:

mov rax, 42
add rbx, 0xff

#2. Register

Operan adalah isi register:

mov rax, rbx        ; salin isi rbx ke rax
add rcx, rdx

#3. Direct (absolute memory)

Alamat ditulis langsung:

mov rax, [msg]      ; muat 8 byte yang dimulai di alamat msg
mov rbx, [0x4000a0] ; alamat absolut (jarang dalam asm modern)

#4. Indirect (register sebagai pointer)

Register berisi alamat; [] membongkar isinya. Ini adalah cara kerja pointer C:

mov rax, [rbx]              ; rax = *(uint64_t*)rbx
mov [rsi], rdx              ; *(uint64_t*)rsi = rdx
mov rax, [rbp-8]            ; rax = *(uint64_t*)(rbp-8)

#5. Indexed (base + index*scale + displacement)

Kombinasi lengkap: [base + index*scale + displacement], dengan scale hanya boleh 1, 2, 4, atau 8:

mov rax, [arr + rcx*8]      ; elemen ke-rcx dari array 64-bit
mov rax, [rbx + rcx*4 + 16] ; base + index*4 + offset
lea rax, [rsi + rdi]        ; lea = hitung alamat, simpan di register

#Little-Endian dalam Praktik

Dari episode 2 kita tahu x86-64 menyimpan byte terendah di alamat terendah. Mari lihat nyata:

section .data
    val dq 0x1122334455667788

Di memori, byte tersimpan sebagai:

alamat:  +0   +1   +2   +3   +4   +5   +6   +7
byte:    0x88 0x77 0x66 0x55 0x44 0x33 0x22 0x11

Membaca dengan mov al, [val] akan memberi 0x88 — byte paling rendah. Inilah alasan mengapa kalian harus konsisten dengan lebar operan saat menulis dan membaca (lihat Callout di episode 2). Untuk membalik urutan byte, x86-64 menyediakan bswap:

mov rax, 0x1122334455667788
bswap rax                ; rax = 0x8877665544332211

#Penutup

Pada episode 5 ini, kalian telah menguasai kosakata dasar assembly x86-64.

Inti yang harus dibawa pulang:

• 16 register general-purpose; sub-register 32/16/8-bit mengakses bagian bawah.
• Menulis ke register 32-bit menghapus bit atas; menulis ke 16/8-bit tidak.
• RIP menunjuk instruksi berikutnya; RFLAGS (ZF, CF, SF, OF) menyimpan status operasi.
• Tipe data NASM: db (1B), dw (2B), dd (4B), dq (8B); times untuk pengulangan.
• Lima addressing mode: immediate, register, direct, indirect, indexed ([base+idx*scale+disp]).
• Little-endian: byte terendah di alamat terendah; gunakan bswap untuk membalik.

Di episode 6 selanjutnya, kalian mulai membuat program "cerdas": control flow dengan jump dan conditional — jmp tanpa syarat, cmp + je/jne/jg/jl, perbandingan unsigned ja/jb, loop/jrcxz, serta cara fungsi dipanggil lewat call/ret. Saatnya mesin mulai mengambil keputusan!