Selasa, 24 Mei 2011

dasar assembler versi indonesia

Memang: dasar-dasar! Ini semua jauh dari sempurna namun juga meliputi tentang segala sesuatu yang perlu Anda ketahui tentang assembler untuk memulai perjalanan Anda membalikkan! Assembler adalah awal dan akhir dari semua bahasa pemrograman. Setelah semua, semua (komputer LOL) diterjemahkan ke bahasa assembler. Dalam bahasa yang paling kita berurusan dengan sintaks yang relatif jelas. Namun, cerita sepenuhnya lainnya dalam perakit dimana kami menggunakan singkatan dan nomor dan di mana semuanya tampak begitu aneh .
I. Pieces, bits and bytes:
* BIT - Benda terkecil data. Hal ini dapat berupa 0 atau 1. Jika Anda menempatkan sekelompok bit bersama-sama, Anda akhirnya dalam 'sistem bilangan biner'

yakni 00000001 = 1 00000010 = 2 00000011 = 3 dll

* BYTE - byte terdiri dari 8 bit. Hal ini dapat memiliki nilai maksimal 255 (0-255). Untuk membuatnya lebih mudah untuk membaca angka biner, kita menggunakan 'sistem bilangan heksadesimal' tersebut. Ini adalah 'dasar-16 sistem', sementara biner adalah 'dasar-2 sistem'

* WORD - Sebuah kata hanya 2 byte menempatkan bersama-sama atau 16 bit. Sebuah kata dapat memiliki nilai maksimal 0FFFFh (atau 65535d).

* DOUBLE WORD - Sebuah kata ganda adalah 2 kata bersama atau 32 bit. Max value = 0FFFFFFFF (atau 4294967295d).

* Kilobyte - 1000 byte? Tidak, kilobyte yang TIDAK sama dengan 1000 byte! Sebenarnya, ada 1024 (32 * 32) byte.

* Megabyte - Sekali lagi, bukan hanya 1 juta byte, tapi 1024 * 1024 atau 1.048.578 byte.

II. Registers:

Register adalah "tempat khusus" di memori komputer Anda di mana kita bisa menyimpan data. Anda dapat melihat mendaftarkan sebagai kotak kecil, dimana kita dapat menyimpan sesuatu: nama, nomor, kalimat. Anda dapat melihat mendaftarkan diri sebagai pengganti.


Rata-rata Wintel CPU yang anda miliki 9 32bit register (w / o register bendera). Nama mereka adalah:
EAX: Extended aki Records
EBX: Extended Base Directory
ECX: Extended Counter Records
EDX: Extended Data Records
ESI: Extended Sumber Indeks
EDI: Extended Tujuan Index
EBP: Extended Base Pointer
ESP: Extended Stack Pointer
EIP: Pointer Instruksi Extended
Umumnya ukuran register 32-bit (= 4 byte). Mereka bisa menyimpan data dari 0-FFFFFFFF (unsigned). Pada awalnya kebanyakan register memiliki fungsi utama tertentu yang menyiratkan nama-nama, seperti ECX = Counter, tetapi pada hari-hari Anda bisa - hampir - gunakan register mana yang Anda suka untuk hanya counter atau barang (yang didefinisikan sendiri, ada kontra-fungsi yang harus digunakan dengan ECX). Fungsi EAX, EBX, ECX, EDX, ESI dan EDI akan dijelaskan ketika saya menjelaskan fungsi-fungsi tertentu yang menggunakan mereka register. Jadi, ada EBP, ESP, EIP kiri:


EBP: EBP telah sebagian besar hubungannya dengan bingkai stack dan stack. Tidak ada yang Anda benar-benar perlu khawatir, ketika Anda mulai.


ESP: ESP menunjuk ke tumpukan proses saat ini. Stack adalah tempat dimana data dapat disimpan untuk digunakan.

EIP: EIP always points to the next instruction that is to be executed.
Ada satu hal lagi yang Anda harus tahu tentang register: meskipun mereka semua 32bits besar, beberapa bagian dari mereka (16bit atau bahkan 8bit) tidak dapat diatasi secara langsung.


Kemungkinannya:


32bit 16bit Register 8bit Pendaftaran Pendaftaran
AX EAX AH / AL
BX EBX BH / BL
CX ECX CH / CL
DX EDX DH / DL
ESI SI -----
EDI DI -----
EBP BP -----
ESP SP -----
EIP IP -----


register A terlihat secara umum cara ini

|--------------------------- EAX: 32bit (=1 DWORD =4BYTES) -------------------------|


|------- AX: 16bit (=1 WORD =2 BYTES) ----|


|- AH:8bit (=1 BYTE)-|- AL:8bit (=1 BYTE)-|


|-----------------------------------------|--------------------|--------------------|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|XXXXXXX XXXXXXXXXXXXX|XXXXXXXXXXXXXXXXXXXX|
|-----------------------------------------|--------------------|--------------------|

Jadi, EAX adalah nama dari register 32-bit, AX adalah nama dari "Low Firman" (16bit) dari EAX dan AL / AH (8bit) adalah "nama" dari "Low Bagian" dan "Bagian Tinggi" dari AX. BTW, 4 byte adalah 1 DWORD, 2 byte adalah 1 WORD.

KETERANGAN: pastikan Anda setidaknya membaca berikut tentang register. Ini cukup praktis untuk tahu itu walaupun tidak begitu penting.


Semua ini memungkinkan kita untuk membuat perbedaan tentang ukuran:

* I. ukuran byte-register: Seperti namanya, register ini semua tepat 1 byte dalam ukuran. Ini tidak berarti bahwa register (32bit) seluruh terisi penuh dengan data! Akhirnya ruang kosong di register hanya diisi dengan nol. Ini adalah register byte berukuran, semua byte 1 atau 8 bit dalam ukuran:
o AL dan AH
o BL dan BH
o CL dan CH
o DL dan DH
* Ii. kata-ukuran register: Apakah 1 kata (= 2 byte = 16 bit) dalam ukuran. Sebuah register kata-berukuran dibangun dari 2 register berukuran byte. Sekali lagi, kita dapat membagi ini tentang tujuan mereka:

o 1. general purpose registers:
AX (kata-ukuran) = AH + AL -> tombol '+' * tidak * berarti: 'add mereka'. AH dan AL ada secara bebas, tetapi bersama-sama mereka membentuk AX. Ini berarti bahwa jika Anda mengubah AH atau AL (atau keduanya), AX akan berubah juga!

akumulator: digunakan untuk operasi matematis, string toko, ..
BX - 'dasar'>: digunakan bersama dengan tumpukan (lihat nanti)
CX -> 'counter
DX - 'data'>: sebagian besar, di sini sisa operasi matematika disimpan
DI - 'tujuan indeks'>: yaitu string akan disalin ke DI
SI - 'sumber indeks'>: yaitu string akan disalin dari SI

o 2. index registers
BP -> 'dasar pointer': poin ke posisi tertentu di stack (lihat nanti)
SP -> 'stack pointer': poin ke posisi tertentu di stack (lihat nanti)

o 3. segment registers:
CS - 'kode segmen'>: instruksi sebuah permohonan untuk mengeksekusi (lihat nanti)
DS -> 'data segmen': data aplikasi Anda membutuhkan (lihat nanti)
ES - 'segmen tambahan'>: duh! (Lihat nanti)
SS -> 'stack segmen': di sini kita akan menemukan tumpukan (lihat nanti)

o 4. special:
IP -> 'instruksi pointer': menunjuk ke instruksi berikutnya. Hanya biarkan saja

* Iii. Doubleword ukuran register:

2 kata = 4 byte = 32 bit. EAX, EBX, ECX, EDX, EDI ...


Jika Anda menemukan sebuah 'E' di depan 16-bit register, itu berarti bahwa Anda berurusan dengan 32-bit register. Jadi, AX = 16-bit, EAX = versi 32-bit EAX.

III. The flags:
Flag bit tunggal yang menunjukkan status sesuatu. Bendera mendaftar di CPU 32-bit modern 32bit besar. Ada 32 bendera yang berbeda, tapi jangan khawatir. Anda kebanyakan akan hanya perlu 3 dari mereka dalam membalikkan. Bendera-Z, O-Flag dan C-Flag. Untuk membalikkan anda harus mengetahui flag-flag ini untuk memahami jika melompat dijalankan atau tidak. register ini sebenarnya kumpulan bendera 1-bit yang berbeda. bendera adalah tanda, seperti lampu hijau berarti: 'ok' dan satu merah 'tidak ok'. bendera hanya dapat '0 'atau '1', yang berarti 'tidak diset' atau 'set'.

* Z-Flag:
o Z-Flag (nol bendera) adalah bendera paling berguna untuk retak. Hal ini digunakan pada sekitar 90% dari semua kasus. Hal ini dapat diatur (status: 1) atau dihapus (status: 0) oleh beberapa opkode saat instruksi terakhir yang dilakukan memiliki 0 sebagai hasilnya. Anda mungkin bertanya-tanya mengapa "CMP" (lebih lanjut tentang ini nanti) dapat mengatur bendera nol, karena membandingkan sesuatu - bagaimana hasil perbandingan akan 0? Jawaban atas ini datang belakangan

* O-Flag:
o O-Flag (bendera overflow) digunakan dalam sekitar 4% dari semua upaya retak. Sudah diatur (status: 1) ketika kegiatan usaha terakhir diubah bit tertinggi dari register yang mendapat hasil operasi. Sebagai contoh: EAX memegang 7FFFFFFF nilai. Jika Anda menggunakan operasi sekarang, yang meningkat EAX oleh 1 O-Flag akan ditetapkan, karena operasi mengubah bit tertinggi EAX (yang tidak diatur dalam 7FFFFFFF, namun ditetapkan dalam 80000000 - calc.exe digunakan untuk mengkonversi nilai heksadesimal ke nilai biner). Lain kebutuhan O-Flag yang akan ditetapkan, adalah bahwa nilai register tujuan bukan 0 sebelum instruksi ataupun setelah itu.

* C-Flag:
o C-Flag (Carry flag) digunakan dalam sekitar 1% dari semua upaya retak. Sudah diatur, jika Anda menambahkan nilai ke register, sehingga akan lebih besar dari FFFFFFFF atau jika Anda mengurangi nilai, sehingga nilai register akan lebih kecil dari 0.

IV. Segments en offsets
Segmen adalah bagian dalam memori di mana instruksi (CS), data (DS), stack (SS) atau hanya sebuah segmen tambahan (ES) disimpan. Setiap segmen dibagi dalam 'offset'. Pada 32-bit aplikasi (Windows 95/98/ME/2000), offset ini diberi nomor dari 00000000 ke FFFFFFFF. 65536 potongan memori sehingga 65536 alamat memori per segmen. Notasi standar untuk segmen dan offset adalah:


SEGMEN: OFFSET = Bersama-sama, mereka menunjuk ke tempat tertentu (alamat) di memori.


Melihatnya seperti ini:


Segmen adalah sebuah halaman dalam sebuah buku: An offset adalah garis tertentu di halaman tersebut.

V. The stack:
Stack adalah bagian dalam memori di mana Anda dapat menyimpan hal yang berbeda untuk digunakan. Lihat t setumpuk buku di dada dimana menaruh terakhir adalah yang pertama untuk ambil keluar. Atau bayangkan tumpukan sebagai keranjang kertas di mana Anda meletakkan dalam lembaran. keranjang adalah stack dan lembaran adalah alamat memori (ditunjukkan oleh stack pointer) dalam segmen stack. Ingat aturan berikut: lembaran terakhir kertas Anda masukkan ke dalam tumpukan, adalah yang pertama yang akan Anda mengambil! 'Push' Perintah menyimpan isi register ke stack. meraih 'pop' Perintah yang terakhir disimpan isi register dari tumpukan dan menempatkannya dalam suatu register tertentu.

VI. INSTRUCTIONS (alphabetical)
Harap dicatat, bahwa semua nilai dalam mnemonik ASM (instruksi) yang * selalu heksadesimal *.




Sebagian besar instruksi memiliki dua operator (seperti "add EAX, EBX"), tetapi beberapa memiliki satu ("tidak EAX") atau bahkan tiga ("IMUL EAX, EDX, 64"). Bila Anda memiliki instruksi yang mengatakan sesuatu dengan "DWORD PTR [XXX]" maka DWORD (4 byte) nilai pada memori offset [XXX] yang dimaksud. Perhatikan bahwa byte disimpan dalam urutan terbalik di memori (Wintel CPU menggunakan apa yang disebut "Little Endian" format. Hal yang sama untuk "WORD PTR [XXX]" (2 byte) dan "BYTE PTR [XXX]" (1 byte).


Sebagian besar instruksi dengan 2 operator dapat digunakan dengan cara berikut (contoh: tambahkan):


add eax, ebx;, Register, Register
add eax, 123,, Register, Nilai
add eax, dword ptr [404000];, Register, Dword Pointer [nilai]
add eax, dword ptr [eax];, Register, Dword Pointer [daftar]
add eax, dword ptr [eax +00404000];, Register, Dword Pointer [register + nilai]
add dword ptr [404000], eax;; Dword Pointer [nilai], Register
add dword ptr [404000], 123;; Dword Pointer [nilai], Nilai
add dword ptr [eax], eax;; Dword Pointer [daftar], Register
add dword ptr [eax], 123;; Dword Pointer [daftar], Nilai
add dword ptr [eax 404000], eax;; Dword Pointer [register + nilai], Register
add dword ptr [eax 404000], 123;; Dword Pointer [register + nilai], nilai

ADD (Penambahan)
Sintaks: ADD tujuan, sumber


Instruksi ADD menambahkan nilai ke sebuah register atau alamat memori. Hal ini dapat digunakan dalam
cara-cara:


instruksi ini dapat mengatur Z-Flag, O-Flag dan C-Flag (dan beberapa orang lain, yang
tidak diperlukan untuk cracking).
Simak
Baca secara fonetik

DAN (Logical Dan)
Sintaks: DAN tujuan, sumber


Instruksi DAN menggunakan logika DAN pada dua nilai.
* Instruksi ini akan * jelas O-Flag dan C-Flag dan dapat mengatur Z-Flag.
Untuk memahami DAN lebih baik, mempertimbangkan dua nilai biner:


1001010110
0101001101


Jika Anda DAN mereka, hasilnya adalah 0001000100
Ketika dua 1 berdiri di bawah satu sama lain, hasilnya adalah bit ini adalah 1, jika tidak: Hasil
adalah 0. Anda dapat menggunakan calc.exe untuk menghitung DAN mudah.


CALL (Call)
Sintaks: sesuatu CALL


CALL instruksi mendorong RVA (Relative Virtual Address) dari instruksi yang
mengikuti CALL ke stack dan panggilan program sub / prosedur.


CALL dapat digunakan dalam cara berikut:


CALL 404000;; PALING UMUM: ALAMAT CALL
CALL EAX;; CALL REGISTER - JIKA EAX AKAN 404000 TI AKAN SAMA SEBAGAI SATU DI ATAS
CALL DWORD PTR [EAX];; PANGGILAN YANG ALAMAT YANG TERSIMPAN DI [EAX]
CALL DWORD PTR [EAX +5];; PANGGILAN YANG ALAMAT YANG TERSIMPAN DI [EAX +5]


-------------------------------------------------- -------------------------------------------


CDQ (Convert DWORD (4Byte) untuk QWord (8 Byte))
Sintaks: CQD


CDQ adalah sebuah instruksi yang selalu membingungkan pemula ketika pertama kali muncul. Hal ini
banyak digunakan di depan divisi dan tidak ada yang lain kemudian menetapkan semua byte dari EDX
dengan nilai bit tertinggi EAX. (Itu adalah: jika EAX <80000000, maka akan EDX
00000000; jika EAX> = 80000000, EDX akan FFFFFFFF).


-------------------------------------------------- -------------------------------------------


CMP (Bandingkan)
Syntax: CMP dest, sumber


Instruksi CMP membandingkan dua hal dan dapat mengatur C / O / flag Z jika hasilnya cocok.


CMP EAX, EBX;, membandingkan dan eax ebx dan set z-bendera jika mereka sama
CMP EAX, [404000];; membandingkan dengan eax dword di 404000
CMP [404000], EAX;; membandingkan dengan eax dword di 404000

DEC (Pengurangan)
Sintaks: DEC .....

DEC digunakan untuk penurunan nilai (yaitu: nilai = nilai-1)


DEC dapat digunakan dalam cara berikut:
DEC eax;; eax penurunan
DEC [eax];; menurunkan dword yang disimpan di [eax]
DEC [401000];; menurunkan dword yang disimpan di [401000]
[Eax 401000] Desember,, menurunkan dword yang disimpan di [eax 401000]


Instruksi DEC dapat mengatur Z / flag O jika hasilnya cocok.

-------------------------------------------------- -------------------------------------------


DIV (Divisi)
Syntax: DIV pembagi


DIV digunakan untuk membagi EAX melalui pembagi (divisi unsigned). Dividen tersebut selalu
EAX, hasilnya disimpan di EAX, dengan modulo-nilai dalam EDX.


Contohnya:
mov eax, 64;; EAX = 64h = 100
mov ecx, 9;; ECX = 9
div ecx;; membagi EAX MELALUI ECX


Setelah divisi EAX = 100 / 9 = 0B dan ECX = 100 MOD 9 = 1


Instruksi div dapat mengatur C / O / flag Z jika hasilnya cocok.


-------------------------------------------------- -------------------------------------------


IDIV (Divisi Integer)
Sintaks: IDIV pembagi


The IDIV bekerja dalam cara yang sama seperti DIV, tetapi IDIV adalah divisi ditandatangani.
Instruksi idiv dapat mengatur C / O / flag Z jika hasilnya cocok.


-------------------------------------------------- -------------------------------------------


IMUL (Perkalian Integer)
Sintaks: nilai IMUL
IMUL dest, nilai, nilai
IMUL dest, nilai


IMUL mengalikan baik EAX dengan nilai (IMUL nilai) atau mengalikan dua nilai dan menempatkan
mereka ke dalam register tujuan (IMUL dest, nilai, nilai) atau menggandakan register
dengan nilai (IMUL dest, nilai).


Jika hasil perkalian terlalu besar untuk masuk ke dalam register tujuan,
O / flag C ditetapkan. Bendera Z dapat ditetapkan juga.


-------------------------------------------------- -------------------------------------------


INC (Increment)
Syntax: INC mendaftar


INC adalah kebalikan dari instruksi Desember, untuk meningkatkan nilai dengan 1.
INC dapat mengatur Z / O flag.




-------------------------------------------------- -------------------------------------------


INT
Syntax: int dest


Menghasilkan panggilan ke interrupt handler. Nilai dest harus berupa integer (misalnya, Int 21h).
INT3 dan KE adalah nomor interupsi yang tidak mengambil parameter tetapi panggilan penangan untuk
menyela 3 dan 4, masing-masing.


-------------------------------------------------- -------------------------------------------


JUMP
Ini adalah mJUMP paling penting dan kondisi yang harus dipenuhi, sehingga
mereka akan dieksekusi (JUMP Penting ditandai dengan * dan sangat penting dengan **):


JA * - Langsung jika (unsigned) di atas - CF = 0 dan ZF = 0
JAE - Langsung jika (unsigned) di atas atau sama - CF = 0
JB * - Langsung jika (unsigned) di bawah ini - CF = 1
JBE - Langsung jika (unsigned) di bawah atau sama - CF = 1 atau ZF = 1
JC - Langsung jika membawa flag - CF 1 =
JCXZ - Langsung jika CX adalah 0 - CX = 0
JE ** - Langsung apabila - ZF = 1
JECXZ - Langsung jika ECX adalah 0 - ECX = 0
JG * - Langsung jika (ditandatangani) yang lebih besar - ZF = 0 dan SF = OF (SF = Daftar Bendera)
JGE * - Langsung jika (ditandatangani) lebih besar atau sama - SF = OF
JL * - Langsung jika (ditandatangani) kurang - SF = OF! (= Tidak!)
JLE * - Langsung jika (ditandatangani) kurang atau sama -! ZF = 1 dan OF = OF
JMP ** - Langsung - Melompat selalu
JNA - Langsung jika (unsigned) tidak di atas - CF = 1 atau ZF = 1
JNAE - Langsung jika (unsigned) tidak di atas atau sama - CF 1 =
JNB - Langsung jika (unsigned) tidak di bawah ini - CF = 0
JNBE - Langsung jika (unsigned) tidak di bawah atau sama - CF = 0 dan ZF = 0
JNC - Langsung jika membawa bendera tidak diatur - CF = 0
JNE ** - Langsung jika tidak sama - ZF 0 =
JNG - Langsung jika (ditandatangani) tidak lebih besar - ZF = 1 atau SF = OF!
JNGE - Langsung jika (ditandatangani) tidak lebih besar atau sama - SF = OF!
JNL - Langsung jika (ditandatangani) tidak kurang - SF = OF
JNLE - Langsung jika (ditandatangani) tidak kurang atau sama - ZF = 0 dan SF = OF
JNO - Langsung jika overflow flag tidak diset - OF = 0
JNP - Langsung jika bendera paritas tidak diatur - PF = 0
JNS - Langsung jika tanda flag tidak diset - SF = 0
JNZ - Langsung jika tidak nol - ZF = 0
JO - Langsung jika flag overflow set - OF = 1
JP - Langsung jika flag paritas set - PF 1 =
JPE - Langsung jika paritas sama - PF 1 =
JPO - Langsung jika paritas ganjil - PF = 0
JS - Langsung jika tanda flag diset - SF 1 =
JZ - Langsung jika nol - ZF 1 =


--------------------------------------------------

LEA (Load Alamat Efektif)
Sintaks: LEA dest, src


LEA dapat diobati dengan cara yang sama seperti instruksi MOV. Hal ini tidak terlalu banyak digunakan untuk perusahaan
asli fungsi, tetapi lebih untuk perkalian cepat seperti ini:


lea eax, dword ptr [ecx + 4 * ebx]
yang memberikan eax nilai 4 * ecx + ebx


-------------------------------------------------- -------------------------------------------


MOV (Pindah)
Sintaks: MOV dest, src


Ini adalah instruksi mudah dipahami. MOV salinan nilai dari src ke tujuan dan src
tetap apa itu sebelumnya.


Ada beberapa varian dari MOV:


MOVS / MOVSB / MOVSW / MOVSD EDI, ESI: Mereka varian copy byte / word / dword ESI menunjuk ke,
untuk ruang EDI poin.


MOVSX: MOVSX memperluas operan Byte atau Word ke Word atau ukuran Dword dan tetap menggunakan tanda
nilai.


MOVZX: MOVZX memperluas operan Byte atau Word ke Word atau ukuran Dword dan mengisi seluruh
ruang dengan 0.


-------------------------------------------------- -------------------------------------------


MUL (perkalian)
Sintaks: nilai MUL


Instruksi ini sama IMUL, kecuali bahwa ia menggandakan unsigned. Hal ini dapat mengatur
O / Z / F flag.


-------------------------------------------------- -------------------------------------------


PDN (Operasi Tidak)
Sintaks: PDN


Instruksi ini tidak apa-apa
Itulah alasan mengapa ia digunakan begitu sering dalam membalikkan


-------------------------------------------------- -------------------------------------------


ATAU (Inklusif Logis Or)
Sintaks: ATAU dest, src


Instruksi ATAU menghubungkan dua nilai dengan menggunakan logis atau inklusif.
Instruksi ini membersihkan O-Flag dan C-Flag dan dapat mengatur Z-Flag.


Untuk memahami ATAU lebih baik, mempertimbangkan dua nilai biner:


1001010110
0101001101

Jika Anda ATAU mereka, hasilnya adalah 1101011111


Hanya ketika ada dua 0 di atas satu sama lain, bit yang dihasilkan adalah 0. Else yang dihasilkan
bit adalah 1. Anda dapat menggunakan calc.exe untuk menghitung OR. Saya harap Anda mengerti mengapa, lain
menuliskan nilai di atas kertas dan coba


-------------------------------------------------- -------------------------------------------


POP
Sintaks: POP dest


POP beban nilai byte / word / dword ptr [esp] dan meletakkannya ke dalam dest. Selain itu
meningkatkan stack dengan ukuran nilai yang muncul dari stack, sehingga berikutnya
POP akan mendapatkan nilai berikutnya.


-------------------------------------------------- -------------------------------------------


PUSH
Sintaks: PUSH operan


PUSH adalah kebalikan dari POP. Ini menyimpan nilai pada stack dan berkurang itu dengan ukuran
dari operan yang mendorong, sehingga poin ESP dengan nilai yang didorong.


-------------------------------------------------- -------------------------------------------


REP / repe / REPZ / REPNE / REPNZ
Syntax: REP / repe / REPZ / REPNE / REPNZ in


Ulangi Berikut String Instruksi: Mengulang in sampai CX kondisi = 0 atau sampai ditunjukkan
(ZF = 1, ZF = 1, ZF = 0, ZF = 0) terpenuhi. Nilai in harus operasi string seperti CMPS, INS,
LODS, MOVS, out, SCAS, atau STOS.


-------------------------------------------------- -------------------------------------------


RET (Return)
Sintaks: RET
RET digit


RET tidak apa-apa selain kembali dari bagian kode yang dicapai dengan menggunakan instruksi CALL.
RET digit membersihkan tumpukan sebelum kembali.


-------------------------------------------------- -------------------------------------------


SUB (Pengurangan)
Syntax: SUB dest, src


SUB adalah kebalikan dari perintah ADD. Hal ini mengurangi nilai src dari nilai
dest dan menyimpan hasilnya dalam dest.


SUB dapat mengatur Z / O / C flag.


-------------------------------------------------- -------------------------------------------


TEST
Sintaks: TEST operan1, operan2


Instruksi ini adalah 99% dari semua kasus yang digunakan untuk "TEST EAX, EAX". Ini melakukan Logis
DAN (DAN instruksi) tetapi tidak menyimpan nilai-nilai. Ini hanya menentukan Z-Flag, ketika EAX adalah 0
atau membersihkan itu, ketika EAX tidak 0. O / flag C selalu dibersihkan.


-------------------------------------------------- -------------------------------------------


XOR
Syntax: XOR dest, src


Instruksi XOR menghubungkan dua nilai menggunakan OR eksklusif logis (ingat ATAU menggunakan
ATAU inklusif).


Instruksi ini membersihkan O-Flag dan C-Flag dan dapat mengatur Z-Flag.
Untuk memahami XOR lebih baik, mempertimbangkan dua nilai biner:


1001010110
0101001101


Jika Anda ATAU mereka, hasilnya adalah 1100011011


Ketika dua bit di atas satu sama lain adalah sama, bit yang dihasilkan adalah 0. Else yang dihasilkan
bit adalah 1. Anda dapat menggunakan calc.exe untuk menghitung XOR.
Penggunaan yang paling sering dilihat dari XOR adalah "XOR, EAX, EAX". Ini akan mengeset EAX ke 0, karena ketika
Anda XOR nilai dengan dirinya sendiri, hasilnya selalu 0. Saya harap Anda mengerti mengapa, lain
menulis nilai di atas kertas dan coba


-------------------------------------------------- -------------------------------------------


VII. Logical Operasi




Berikut mengikuti paling banyak digunakan di meja referensi.




Referensi Tabel


Hasil operasi dest src
DAN 1 1 1
1 0 0
0 1 0
0 0 0
ATAU 1 1 1
1 0 1
0 1 1
0 0 0
XOR 1 1 0
1 0 1
0 1 1
0 0 0
TIDAK 0 N / A 1
1 N / A 0



JUST GOOGLE TRANSLATE...