x86 Instructions

Az ebben a szakaszban szereplő listákban a csillaggal (*) jelölt utasítások különösen fontosak. Az ilyen jelöléssel nem rendelkező utasítások nem kritikusak.

Az x86 processzoron az utasítások változó méretűek, ezért a visszafelé szétszerelés a mintaegyezés gyakorlata. Ha visszafelé szeretne szétszerelni egy címet, kezdje el szétszerelni a szétszerelést a kívántnál távolabb, majd várja meg, amíg az utasítások értelmessé nem válik. Előfordulhat, hogy az első néhány utasításnak nincs értelme, mert lehet, hogy egy utasítás közepén kezdett szétszerelni. Sajnos előfordulhat, hogy a szétszerelés soha nem szinkronizálódik az utasításfolyammal, és meg kell próbálnia a szétszerelést egy másik kiindulási ponton, amíg meg nem talál egy működő kiindulási pontot.

For well-packed switch statements, the compiler emits data directly into the code stream, so disassembling through a switch statement will usually stumble across instructions that make no sense (because they are really data). Keresse meg az adatok végét, és folytassa a szétszerelést.

Utasítás jelölése

Az utasítások általános jelölése, hogy a célregisztrációt a bal oldalon, a forrást pedig a jobb oldalon kell elhelyezni. A szabály alól azonban lehetnek kivételek.

Az aritmetikai utasítások általában kétregisztrálást jelentenek a forrás- és célregisztrálók kombinálásával. Az eredmény a célhelyen lesz tárolva.

Az utasítások némelyike 16 és 32 bites verzióval is rendelkezik, de itt csak a 32 bites verziók szerepelnek. Itt nem szerepel a lebegőpontos utasítások, a kiemelt utasítások és a csak szegmentált modellekben használt utasítások (amelyeket a Microsoft Win32 nem használ).

A helytakarékosság érdekében az utasítások nagy része kombinált formában jelenik meg, ahogyan az alábbi példában is látható.

*

MOV

r1, r/m/#n

r1 = r/m/#n

azt jelenti, hogy az első paraméternek regiszternek kell lennie, de a második lehet egy regiszter, egy memóriahivatkozás vagy egy azonnali érték.

Ha még több helyet szeretne megtakarítani, az utasítások az alábbi módon is kifejezhetők.

*

MOV

r1/m, r/m/#n

r1/m = r/m/#n

Ami azt jelenti, hogy az első paraméter lehet egy regiszter vagy egy memóriahivatkozás, a második pedig egy regiszter, egy memóriahivatkozás vagy egy azonnali érték.

Ha másként nem jelezzük, a rövidítés használatakor nem választhat memóriát a forrás és a cél számára.

Ezenkívül egy bitméretű utótag (8, 16, 32) hozzáfűzhető a forráshoz vagy a célhoz annak jelzésére, hogy a paraméternek ilyen méretűnek kell lennie. Az r8 például egy 8 bites regisztert jelent.

Memória, adatátvitel és adatkonvertálás

A memória- és adatátviteli utasítások nem befolyásolják a jelzőket.

Érvényes cím

*

LEA

r, m

Töltse be az érvényes címet. (r = m címe)

Például a LEA eax, [esi+4] azt jelenti, eax = esi + 4. Ezt az utasítást gyakran használják aritmetikai műveletek végrehajtására.

Adatátvitel

	MOV	r1/m, r2/m/#n	r1/m = r/m/#n
	MOVSX	r1, r/m	Áthelyezés jelbővítménnyel.
*	MOVZX	r1, r/m	Áthelyezés nulla kiterjesztéssel.

MOVSX and MOVZX are special versions of the mov instruction that perform sign extension or zero extension from the source to the destination. Ez az egyetlen utasítás, amely lehetővé teszi, hogy a forrás és a cél különböző méretű legyen. (És valójában különböző méretűnek kell lenniük.

Veremkezelés

The stack is pointed to by the esp register. The value at esp is the top of the stack (most recently pushed, first to be popped); older stack elements reside at higher addresses.

	PUSH	r/m/#n	Érték leküldése a verembe.
	találkozási pont	r/m	Pop érték a veremből.
	PUSHFD		Jelölők leküldése a verembe.
	POPFD		Pop flags from stack.
	PUSHAD		Az összes egész számregisztrátor leküldése.
	POPAD		Pop all integer registers.
	ENTER	#n, #n	Veremkeret összeállítása.
*	LEAVE		Veremkeret bontása

The C/C++ compiler does not use the enter instruction. (The enter instruction is used to implement nested procedures in languages like Algol or Pascal.)

The leave instruction is equivalent to:

mov esp, ebp
pop ebp

Adatkonvertálás

CBW	Convert byte (al) to word (ax).
CWD	Convert word (ax) to dword (dx:ax).
CWDE	Convert word (ax) to dword (eax).
CDQ	convert dword (eax) to qword (edx:eax).

Minden átalakítás előjelkiterjesztést hajt végre.

Számtani és bitmanipuláció

Minden aritmetikai és bitkezelési utasítás módosítja a jelzőket.

Számtan

	ADD	r1/m, r2/m/#n	r1/m += r2/m/#n
	ADC	r1/m, r2/m/#n	r1/m += r2/m/#n + carry
	SUB	r1/m, r2/m/#n	r1/m -= r2/m/#n
	SBB	r1/m, r2/m/#n	r1/m -= r2/m/#n + carry
	NEG	r1/m	r1/m = -r1/m
	INC	r/m	r/m += 1
	DEC	r/m	r/m -= 1
	CMP	r1/m, r2/m/#n	Compute r1/m - r2/m/#n

The cmp instruction computes the subtraction and sets flags according to the result, but throws the result away. It is typically followed by a conditional jump instruction that tests the result of the subtraction.

	MUL	r/m8	ax = al * r/m8
	MUL	r/m16	dx:ax = ax * r/m16
	MUL	r/m32	edx:eax = eax * r/m32
	IMUL	r/m8	ax = al * r/m8
	IMUL	r/m16	dx:ax = ax * r/m16
	IMUL	r/m32	edx:eax = eax * r/m32
	IMUL	r1, r2/m	r1 *= r2/m
	IMUL	r1, r2/m, #n	r1 = r2/m * #n

Aláíratlan és aláírt szorzás. A szorzás utáni jelzők állapota nincs meghatározva.

	DIV	r/m8	(ah, al) = (ax % r/m8, ax / r/m8)
	DIV	r/m16	(dx, ax) = dx:ax / r/m16
	DIV	r/m32	(edx, eax) = edx:eax / r/m32
	IDIV	r/m8	(ah, al) = ax / r/m8
	IDIV	r/m16	(dx, ax) = dx:ax / r/m16
	IDIV	r/m32	(edx, eax) = edx:eax / r/m32

Aláíratlan és aláírt osztás. A pszeudokód magyarázatában az első regisztráló megkapja a maradékot, a második pedig a hányadost. Ha az eredmény túlcsordul a célhelyen, a rendszer egy megosztott túlcsordulási kivételt hoz létre.

A osztás utáni zászlók állapota nincs meghatározva.

*

SETcc

r/m8

Set r/m8 to 0 or 1

If the condition cc is true, then the 8-bit value is set to 1. Ellenkező esetben a 8 bites érték nullára van állítva.

Bináris kódolású decimális

Ezek az utasítások csak akkor jelennek meg, ha a COBOL-ban írt kód hibakeresését látja.

	DAA	Decimális igazítás a hozzáadás után.
	DAS	Decimális igazítás kivonás után.

These instructions adjust the al register after performing a packed binary-coded decimal operation.

AAA	Az ASCII az összeadás után módosul.
AAS	Az ASCII a kivonás után módosul.

These instructions adjust the al register after performing an unpacked binary-coded decimal operation.

AAM	ASCII-beállítás szorzás után.
AAD	Az ASCII az osztás után módosul.

These instructions adjust the al and ah registers after performing an unpacked binary-coded decimal operation.

Bit

	AND	r1/m, r2/m/#n	r1/m = r1/m and r2/m/#n
	OR	r1/m, r2/m/#n	r1/m = r1/m or r2/m/#n
	XOR	r1/m, r2/m/#n	r1/m = r1/m xor r2/m/#n
	NOT	r1/m	r1/m = bitwise not r1/m
*	TEST	r1/m, r2/m/#n	Compute r1/m and r2/m/#n

The test instruction computes the logical AND operator and sets flags according to the result, but throws the result away. Ezt általában egy feltételes ugrási utasítás követi, amely teszteli a logikai ÉS eredményét.

	SHL	r1/m, cl/#n	r1/m <<= cl/#n
	SHR	r1/m, cl/#n	r1/m >>= cl/#n zero-fill
*	SAR	r1/m, cl/#n	r1/m >>= cl/#n sign-fill

Az utolsó eltolt bit a hordozásba kerül.

SHLD

r1, r2/m, cl/#n

Shift balra dupla.

Shift r1 left by cl/#n, filling with the top bits of r2/m. Az utolsó eltolt bit a hordozásba kerül.

SHRD

r1, r2/m, cl/#n

Jobbra, dupla váltás.

Shift r1 right by cl/#n, filling with the bottom bits of r2/m. Az utolsó eltolt bit a hordozásba kerül.

ROL	r1, cl/#n	Rotate r1 left by cl/#n.
ROR	r1, cl/#n	Rotate r1 right by cl/#n.
RCL	r1, cl/#n	Rotate r1/C left by cl/#n.
RCR	r1, cl/#n	Rotate r1/C right by cl/#n.

A forgatás olyan, mint az eltolódás, azzal a kivételsel, hogy az eltolt bitek újra megjelennek a bejövő kitöltési bitekként. A forgatási utasítások C nyelvű verziója tartalmazza a átviteli bitet a forgatásba.

BT	r1, r2/#n	Copy bit r2/#n of r1 into carry.
BTS	r1, r2/#n	Set bit r2/#n of r1, copy previous value into carry.
BTC	r1, r2/#n	Clear bit r2/#n of r1, copy previous value into carry.

Folyamat vezérlése

	Jcc	dest	Branch conditional.
	JMP	dest	Jump direct.
	JMP	r/m	Jump indirect.
	CALL	dest	Call direct.
*	CALL	r/m	Call indirect.

The call instruction pushes the return address onto the stack then jumps to the destination.

*

RET

#n

visszatérítés

The ret instruction pops and jumps to the return address on the stack. A nonzero #n in the RET instruction indicates that after popping the return address, the value #n should be added to the stack pointer.

LOOP	Decrement ecx and jump if result is nonzero.
LOOPZ	Decrement ecx and jump if result is nonzero and zr was set.
LOOPNZ	Decrement ecx and jump if result is nonzero and zr was clear.
JECXZ	Jump if ecx is zero.

Ezek az utasítások az x86 CISC-örökségének maradványai, és a legújabb processzorokban valójában lassabbak, mint a hosszú út során kiírt egyenértékű utasítások.

Sztringek kezelése

	MOVST	Move T from esi to edi.
	CMPST	Compare T from esi with edi.
	SCAST	Scan T from edi for accT.
	LODST	Load T from esi into accT.
	STOST	Store T to edi from accT.

After performing the operation, the source and destination register are incremented or decremented by sizeof(T), according to the setting of the direction flag (up or down).

The instruction can be prefixed by REP to repeat the operation the number of times specified by the ecx register.

The rep mov instruction is used to copy blocks of memory.

The rep stos instruction is used to fill a block of memory with accT.

Zászlók

LAHF	Load ah from flags.
SAHF	Store ah to flags.
STC	Set carry.
CLC	Clear carry.
CMC	Complement carry.
STD	Set direction to down.
CLD	Set direction to up.
STI	Enable interrupts.
parancssori felület	Disable interrupts.

Összekapcsolt utasítások

XCHG	r1, r/m	Swap r1 and r/m.
XADD	r1, r/m	Add r1 to r/m, put original value in r1.
CMPXCHG	r1, r/m	Hasonlítsa össze és cserélje le a feltételes feltételeket.

The cmpxchg instruction is the atomic version of the following:

   cmp     accT, r/m
   jz      match
   mov     accT, r/m
   jmp     done
match:
   mov     r/m, r1
done:

Vegyes

	INT	#n	Trap to kernel.
	BOUND	r, m	Trap if r not in range.
*	NOP		No operation.
	XLATB		al = [ebx + al]
	BSWAP	r	Bájtsorrend felcserélése a regisztrációban.

Here is a special case of the int instruction.

INT

3

Hibakereső töréspont-csapda.

The opcode for INT 3 is 0xCC. The opcode for NOP is 0x90.

A kód hibakeresése esetén előfordulhat, hogy ki kell javítania néhány kódot. Ezt úgy teheti meg, hogy lecseréli a megsértő bájtokat 0x90.

Szólások

	XOR	r, r	r = 0
	TEST	r, r	Check if r = 0.
*	ADD	r, r	Shift r left by 1.