SanzSkuy at 06:46, 9 October 2026

2026-10-09T06:46:15Z

← Older revision		Revision as of 06:46, 9 October 2026
Line 22:		Line 22:
	\|<------------------- %rax (64 bit) ------------------->\|		\|<------------------- %rax (64 bit) ------------------->\|
	\|<------ %eax (32 bit) ----->\|		\|<------ %eax (32 bit) ----->\|
	\|<- %ax (16) ->\|		\|<- %ax (16) ->\|
	\|%al(8)\|		\|%al(8)\|
	</pre>		</pre>

SanzSkuy: Created page with "CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer. == Sejarah penamaan == Penamaan register berlapis karena evolusi instruction set: {| class="wikitable" ! Generasi !! Lebar !! Nama register !! Catatan |- | 8086 || 16-bit || `%ax`, `%bx`, `%cx`, `%dx`, `%si`, `%di`, `%bp`, `%sp` || Nama mencerminkan fungsi (accumulat..."

2026-10-09T06:45:45Z

Created page with "CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer. == Sejarah penamaan == Penamaan register berlapis karena evolusi instruction set: {| class="wikitable" ! Generasi !! Lebar !! Nama register !! Catatan |- | 8086 || 16-bit || <code>%ax</code>, <code>%bx</code>, <code>%cx</code>, <code>%dx</code>, <code>%si</code>, <code>%di</code>, <code>%bp</code>, <code>%sp</code> || Nama mencerminkan fungsi (accumulat..."

New page

CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer.

== Sejarah penamaan ==
Penamaan register berlapis karena evolusi instruction set:

{| class="wikitable"
! Generasi !! Lebar !! Nama register !! Catatan
|-
| 8086 || 16-bit || <code>%ax</code>, <code>%bx</code>, <code>%cx</code>, <code>%dx</code>, <code>%si</code>, <code>%di</code>, <code>%bp</code>, <code>%sp</code> || Nama mencerminkan fungsi (accumulator, counter, source/destination index, stack pointer)
|-
| IA32 || 32-bit || <code>%eax</code> … <code>%ebp</code> || Prefix <code>e</code> = ''extended''
|-
| x86-64 || 64-bit || <code>%rax</code> … <code>%rbp</code> || Prefix <code>r</code>
|-
| x86-64 (baru) || 64-bit || <code>%r8</code> … <code>%r15</code> || Konvensi baru, suffix <code>d</code>/<code>w</code>/<code>b</code> untuk 32/16/8-bit
|}

== Sub-register (nested boxes) ==
<code>%rax</code>, <code>%eax</code>, <code>%ax</code>, <code>%al</code> '''bukan''' empat register berbeda, melainkan satu register fisik yang diakses dengan lebar berbeda:

<pre>
|<------------------- %rax (64 bit) ------------------->|
|<------ %eax (32 bit) ----->|
|<- %ax (16) ->|
|%al(8)|
</pre>

* Operasi byte → least significant byte
* Operasi 16-bit → 2 byte terbawah
* Operasi 32-bit → 4 byte terbawah
* Operasi 64-bit → seluruh register

== Aturan sisa byte saat menulis ke register ==
Ketika instruksi menghasilkan nilai kurang dari 8 byte ke register:

{| class="wikitable"
! Ukuran tulis !! Efek ke byte sisanya
|-
| 1 byte / 2 byte || '''Tidak berubah'''
|-
| 4 byte || 4 byte atas '''di-nol-kan'''
|}

Contoh, dengan <code>%rax = 0x1122334455667788</code>:

<syntaxhighlight lang="gas">
movb $0xAA, %al # %rax = 0x11223344556677AA (sisanya utuh)
movw $0xAAAA, %ax # %rax = 0x112233445566AAAA (sisanya utuh)
movl $0xAAAA, %eax # %rax = 0x000000000000AAAA (4 byte atas = 0)
</syntaxhighlight>

'''Kenapa?''' Aturan zero-upper diadopsi saat ekspansi IA32 → x86-64 supaya hasil tulisan tidak bergantung pada isi lama register (menghindari ''partial register dependency''), sehingga eksekusi out-of-order lebih lancar. Compiler memanfaatkannya, misalnya <code>mov $0x0,%eax</code> untuk <code>return 0</code>.

== Peran register (System V ABI) ==
{| class="wikitable"
! Register !! Peran
|-
| <code>%rax</code> || Return value
|-
| <code>%rdi</code>, <code>%rsi</code>, <code>%rdx</code>, <code>%rcx</code>, <code>%r8</code>, <code>%r9</code> || Argumen ke-1 sampai ke-6 (urut)
|-
| <code>%rsp</code> || Stack pointer (spesial, dipakai otomatis oleh <code>push</code>/<code>pop</code>/<code>call</code>/<code>ret</code>)
|-
| <code>%rbx</code>, <code>%rbp</code>, <code>%r12</code>–<code>%r15</code> || '''Callee saved''': fungsi yang dipanggil wajib mengembalikan nilainya
|-
| <code>%r10</code>, <code>%r11</code> (+ register argumen & <code>%rax</code>) || '''Caller saved''': boleh dirusak oleh fungsi yang dipanggil
|}

Jembatan keledai urutan argumen: '''"Diane's Silk Dress Costs $89"''' → <code>di</code>, <code>si</code>, <code>dx</code>, <code>cx</code>, <code>8</code>, <code>9</code>.

=== Contoh: <code>multstore</code> ===
<syntaxhighlight lang="gas">
push %rbx # rbx callee-saved → simpan nilai lama
mov %rdx,%rbx # rdx = argumen ke-3 (dest), amankan di rbx
call mult2 # x, y masih di rdi & rsi
mov %rax,(%rbx) # *dest = hasil mult2 (rax)
pop %rbx # pulihkan rbx
ret
</syntaxhighlight>
<code>dest</code> dipindah ke <code>%rbx</code> karena <code>%rdx</code> caller-saved (bisa dirusak <code>mult2</code>), sedangkan <code>%rbx</code> dijamin selamat melewati <code>call</code>.

= 3.4.1 Operand Specifiers =

== Tiga jenis operand ==
{| class="wikitable"
! Jenis !! Contoh !! Arti
|-
| Immediate || <code>$-577</code>, <code>$0x1F</code> || Konstanta, nilai tertanam di instruksi
|-
| Register || <code>%rax</code>, <code>%al</code> || Isi register, notasi <code>R[r<sub>a</sub>]</code>
|-
| Memory || <code>0x104</code>, <code>(%rax)</code>, <code>8(%rax)</code> || Isi memori di ''effective address'', notasi <code>M[Addr]</code>
|}

'''Perhatian:''' <code>$0x10</code> = angka 16, sedangkan <code>0x10</code> (tanpa <code>$</code>) = isi memori di alamat 16.

== <code>%rax</code> vs <code>(%rax)</code> ==
* <code>%rax</code> → isi register itu sendiri (seperti <code>p</code> di C)
* <code>(%rax)</code> → isi register dipakai sebagai alamat, lalu baca memori di alamat itu (seperti <code>*p</code> di C)

Kurung <code>( )</code> di AT&T = dereference. Di AT&T, register '''wajib''' pakai <code>%</code>; <code>rax</code> tanpa <code>%</code> akan dianggap nama simbol.

{| class="wikitable"
! Maksud !! AT&T (gcc, CS:APP) !! Intel (NASM, MASM)
|-
| Isi register || <code>%rax</code> || <code>rax</code>
|-
| Isi memori di alamat rax || <code>(%rax)</code> || <code>[rax]</code>
|-
| Konstanta || <code>$5</code> || <code>5</code>
|}

== Bentuk umum memory reference ==
<pre>
Imm(rb, ri, s) → alamat = Imm + R[rb] + R[ri] · s
</pre>
* <code>Imm</code>: displacement konstanta
* <code>rb</code>: base register (64-bit)
* <code>ri</code>: index register (64-bit)
* <code>s</code>: skala, hanya '''1, 2, 4, atau 8''' (ukuran <code>char</code>, <code>short</code>, <code>int</code>, <code>long</code>/pointer)

Semua mode lain adalah kasus khusus dengan komponen yang dihilangkan:

{| class="wikitable"
! Form !! Effective address !! Nama
|-
| <code>Imm</code> || <code>Imm</code> || Absolute
|-
| <code>(rb)</code> || <code>R[rb]</code> || Indirect
|-
| <code>Imm(rb)</code> || <code>Imm + R[rb]</code> || Base + displacement
|-
| <code>(rb,ri)</code> || <code>R[rb] + R[ri]</code> || Indexed
|-
| <code>Imm(rb,ri)</code> || <code>Imm + R[rb] + R[ri]</code> || Indexed
|-
| <code>(,ri,s)</code> || <code>R[ri]·s</code> || Scaled indexed
|-
| <code>Imm(,ri,s)</code> || <code>Imm + R[ri]·s</code> || Scaled indexed
|-
| <code>(rb,ri,s)</code> || <code>R[rb] + R[ri]·s</code> || Scaled indexed
|-
| <code>Imm(rb,ri,s)</code> || <code>Imm + R[rb] + R[ri]·s</code> || Scaled indexed
|}

Tambahan x86-64 yang tidak ada di tabel: '''RIP-relative''', misalnya <code>lea 0x0(%rip),%rdi</code>, alamat dihitung relatif terhadap instruksi berikutnya (dipakai untuk data global/string literal).

== Kegunaan: akses array dan struct ==
<syntaxhighlight lang="c">
long a[100];
x = a[i];
</syntaxhighlight>
Dengan <code>a</code> di <code>%rdx</code> dan <code>i</code> di <code>%rcx</code>:
<syntaxhighlight lang="gas">
movq (%rdx,%rcx,8), %rax # alamat = a + i*8
</syntaxhighlight>
Satu instruksi tanpa perkalian terpisah. Untuk <code>arr[i].field</code>, offset field masuk ke <code>Imm</code>.

== Cara menghitung nilai operand ==
Untuk memory operand selalu dua langkah:
# Hitung alamat: <code>Imm + R[rb] + R[ri]·s</code>
# Baca isi memori di alamat tersebut

'''Jebakan umum:'''
* Displacement tanpa <code>0x</code> adalah '''desimal''': <code>260</code> = <code>0x104</code>, <code>16</code> = <code>0x10</code>
* Koma di depan (<code>0xFC(,%rcx,4)</code>) berarti '''tanpa base register'''
* Perhatikan carry saat menjumlah hex: <code>0xFC + 4 = 0x100</code>
* Jangan berhenti di alamat; jawaban adalah '''isi''' memorinya

=== Contoh (Practice Problem 3.1) ===
Data: <code>%rax = 0x100</code>, <code>%rcx = 0x1</code>, <code>%rdx = 0x3</code>; memori <code>0x100→0xFF</code>, <code>0x104→0xAB</code>, <code>0x108→0x13</code>, <code>0x10C→0x11</code>.

{| class="wikitable"
! Operand !! Jenis !! Alamat !! Nilai
|-
| <code>%rax</code> || Register || — || <code>0x100</code>
|-
| <code>0x104</code> || Absolute || <code>0x104</code> || <code>0xAB</code>
|-
| <code>$0x108</code> || Immediate || — || <code>0x108</code>
|-
| <code>(%rax)</code> || Indirect || <code>0x100</code> || <code>0xFF</code>
|-
| <code>4(%rax)</code> || Base + displacement || <code>4 + 0x100 = 0x104</code> || <code>0xAB</code>
|-
| <code>9(%rax,%rdx)</code> || Indexed || <code>9 + 0x100 + 3 = 0x10C</code> || <code>0x11</code>
|-
| <code>260(%rcx,%rdx)</code> || Indexed || <code>0x104 + 1 + 3 = 0x108</code> || <code>0x13</code>
|-
| <code>0xFC(,%rcx,4)</code> || Scaled indexed || <code>0xFC + 1·4 = 0x100</code> || <code>0xFF</code>
|-
| <code>(%rax,%rdx,4)</code> || Scaled indexed || <code>0x100 + 3·4 = 0x10C</code> || <code>0x11</code>
|}

Accessing Information - Revision history

SanzSkuy at 06:46, 9 October 2026