Базовая система команд микропроцессора ia -32

Базовую систему команд микропроцессора можно условно разделить на несколько групп по функциональному назначению (см. табл.8).

· команды передачи данных

· команды работы со стеком

· команды ввода-вывода

· арифметические команды

· логические команды

· сдвиговые команды

· команды управления флагами

· команды прерываний

· команды передачи управления

· команды поддержки языков высокого уровня

· команды синхронизации работы процессора

· команды обработки цепочки бит

· строковые команды

· команды управления защитой (не рассматриваются)

· команды управления кэшированием (не рассматриваются)

Кроме базовой системы команд процессора существуют также команды расширений:

X87 – расширение, содержащее команды математического сопроцессора (работа с вещественными числами)

MMX – расширение, содержащее команды для кодирования/декодирования потоковых аудио/видео данных;

SSE – расширение включает в себя набор инструкций, который производит операции со скалярными и упакованными типами данных;

SSE2 – модификация SSE, содержит инструкции для потоковой обработки целочисленных данных, что делает это расширение более предпочтительным для целочисленных вычислений, нежели использование набора инструкций MMX, появившегося гораздо раньше;

SSE3, SSE4 – содержат дополнительные инструкции расширения SSE.

 

 

В таблице приняты следующие обозначения

r – регистр

m – ячейка памяти

c – константа

8, 16, 32 – размер в битах

W – запись бита в регистре признаков

U – значение бита в регистре признаков неизвестно после выполнения операции

- – значение бита в регистре признаков не изменилось

+ – значение бита в регистре признаков меняется в соответствии с результатом

 

На все базовые команды процессора накладываются следующие ограничения:

1. Нельзя в одной команде оперировать двумя областями памяти одновременно. Если такая необходимость возникает, то нужно использовать в качестве промежуточного буфера любой доступный в данный момент регистр общего назначения.

2. Нельзя оперировать сегментным регистром и значением непосредственно из памяти. Поэтому для выполнения такой операции нужно использовать промежуточный объект. Это может быть регистр общего назначения или стек.

3. Нельзя оперировать двумя сегментными регистрами. Это объясняется тем, что в системе команд нет соответствующего кода операции. Но необходимость в таком действии часто возникает. Выполнить такую пересылку можно, используя в качестве промежуточных регистры общего назначения. Например,

mov ax,ds

mov es,ax; es=ds

4. Нельзя использовать сегментный регистр CS в качестве операнда приемника, поскольку в архитектуре микропроцессора пара CS:EIP всегда содержит адрес команды, которая должна выполняться следующей. Изменение содержимого регистра CS фактически означало бы операцию перехода, а не модификации, что недопустимо.

5. Операнды команды, если это не оговаривается дополнительно в описании команды, должны быть одного размера.

Таблица 4

Команда	Операнды	Флаги																			Пояснение	Описание
		O			D		I		T		S		Z		A		P		C
Команды передачи данных
MOV	r/m8,r8 r/m16,r16 r/m32,r32 r8,r/m8 r16,r/m16 r32,r/m32 r/m8,imm8 r/m16,c16 r/m32,c32	-		-		-		-		-		-		-		-		-		r/m8=r8 r/m16=r16 r/m32=r32 r8=r/m8 r16=r/m16 r32=r/m32 r/m8=с8 r/m16=с16 r/m32=с32		Пересылка операндов
XCHG	r/m8, r8 r8, r/m8 r/m16,r16 r16,r/m16 r/m32,r32 r32,r/m32	-		-		-		-		-		-		-		-		-		r/m8 ↔r8 r8 ↔r/m8 r/m16↔r16 r16 ↔r/m16 r/m32↔r32 r32 ↔r/m32		Обмен операндов
BSWAP	r32	-		-		-		-		-		-		-		-		-		TEMP ← r32 r32[7..0]←TEMP(31..24] r32[15..8]←TEMP(23..16] r32[23..16]←TEMP(15..8] r32[31..24]←TEMP(7..0]		Перестановка байтов из порядка "младший – стар­ший" в порядок "старший – млад­ший". (c 486 проц.)
MOVSX	r16,r/m8 r32,r/m8 r32,r/m16	-		-		-		-		-		-		-		-		-		r16,r/m8 DW ← DB r32,r/m8 DD ← DB r32,r/m16 DD ← DW		Пересылка с рас­ши­ре­ни­ем форма­та и дублирова­ни­ем знакового бита (с 386 проц.)
MOVZX	r16,r/m8 r32,r/m8 r32,r/m16	-		-		-		-		-		-		-		-		-		r16,r/m8 DW ← DB r32,r/m8 DD ← DB r32,r/m16 DD ← DW		Пересылка с рас­ши­ре­ни­ем форма­та и дублирова­ни­ем нулевого бита (с 386 проц.)
XLAT XLATB	m8	-		-		-		-		-		-		-		-		-		AL=DS:[(E)BX + unsigned AL]		Загрузить в AL байт из таблицы в сегменте данных, на начало которой указывает EBX (ВХ); начальное зна­чение AL игра­ет роль смещения.
LEA	r16, m r32, m	-		-		-		-		-		-		-		-		-		r16=offset m r32=offset m		Загрузка эффективного адреса.
LDS	r16,m16 r32,m16	-		-		-		-		-		-		-		-		-		DS:r=offset m		Загрузить пару регистров из памя­ти.
LSS																				SS:r=offset m
LES																				ES:r=offset m
LFS																				FS:r=offset m
LGS																				GS:r=offset m
Команды установки единичного значения
SETA SETNBE	r/m8	-		-		-		-		-		-		-		-		-		CF=0 и ZF=0		Проверяет условие состояния битов регистра EFLAGS и если условие выполняется, то первый бит байта устанавливается в 1, в противном случае в 0. Усло­вия аналогич­ны­ условным перехо­дам (je, jc). Например, SETE AL. (с 386 микропроцессора)
SETAE SETNB SETNC		-		-		-		-		-		-		-		-		-		CF=0
SETB SETC SETNAE		-		-		-		-		-		-		-		-		-		CF=1
SETBE SETNA		-		-		-		-		-		-		-		-		-		CF=1 или ZF=1
SETE SETZ		-		-		-		-		-		-		-		-		-		ZF=1
SETG SETNLE		-		-		-		-		-		-		-		-		-		ZF=0 и SF=OF
SETGE SETNL		-		-		-		-		-		-		-		-		-		SF=OF
SETL SETNGE		-		-		-		-		-		-		-		-		-		SF<>OF
SETLE SETNG		-		-		-		-		-		-		-		-		-		ZF=1 или SF<>OF
SETNE SETNZ		-		-		-		-		-		-		-		-		-		ZF=0
SETNO		-		-		-		-		-		-		-		-		-		OF=0
SETNP SETPO		-		-		-		-		-		-		-		-		-		PF=0
SETNS		-		-		-		-		-		-		-		-		-		SF=0
SETO		-		-		-		-		-		-		-		-		-		OF=1
SETP SETPE		-		-		-		-		-		-		-		-		-		PF=1
SETS		-		-		-		-		-		-		-		-		-		SF=1
Команды работы со стеком
PUSH	r/m32 c32 r/m16	-		-		-		-		-		-		-		-		-		ESP=ESP-4; SS:ESP=r/m32/c SP=SP-2; SS:SP=r/m16		Поместить в стек двой­ное слово (слово).
POP PUSHA PUSHAD	r/m32 r/m16 -	-		-		-		-		-		-		-		-		-		r/m32=SS:ESP ESP=ESP+4 r/m16=SS:SP; SP=SP+4 16-разр. 32-разр.		Извлечь из стека двойное слово (слово). Поместить в стек регистры EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP. (с 386 проц.)
POPA POPAD	-	-		-		-		-		-		-		-		-		-		16-разр. 32-разр.		Извлечь из стека регистры EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP. (с 386 проц.)
PUSHF	-	W		W		W		W		W		W		W		W		W				Поместить в стек регистр EFLAGS
POPF	-	W		W		W		W		W		W		W		W		W				Извлечь из стека регистр EFLAGS
Команды ввода-вывода
IN	AL,c8 AX,c8 EAX,c8 AL,DX AX,DX EAX,DX	-		-		-		-		-		-		-		-		-		AL= port byte AX= port word EAX= port dword AL= [DX-port] AX= [DX-port] EAX= [DX-port]		Ввод из порта
OUT	c8, AL c8, AX c8, EAX DX, AL DX, AX DX, EAX	-		-		-		-		-		-		-		-		-		port byte=AL port word=AX port dword=EAX [DX-port]=AL [DX-port]=AX [DX-port]=EAX		Вывод в порт
INSB INSW INSD	-	-		-		-		-		-		-		-		-		-		ES:(E)DI = [DX-port]		Выводит данные из порта, адресуе­мого DX в ячейку памяти ES:[(E)DI]. После ввода байта, слова или двойно­го слова произво­дится коррекция EDI/DI на 1,2,4. При наличии пре­фикса REP про­цесс продолжа­ется, пока СХ>0.
OUTSB OUTSW OUTSD	-	-		-		-		-		-		-		-		-		-		[DX-port]=DS:(E)DI		Вводит данные из ячейки памяти, оп­ределяемой регис­трами DS:[(E)SI], в выходной порт, ад­рес которого на­ходится в регистре DX. После вывода данных произво­дится коррекция указателя ESI/SI на 1,2,4.
Команды целочисленной арифметики
ADD	r/m8,с8 r/m16,с16 r/m32,с32 r/m8,r8 r/m16,r16 r/m32,r32 r8,r/m8 r16,r/m16 r32,r/m32	+	-				-		-		+		+		+		+		+		r/m8=r/m8+с8 r/m16=r/m16+с16 r/m32=r/m32+c32 r/m8= r/m8+r8 r/m16= r/m16+r16 r/m32= r/m32+r32 r8=r8+r/m8 r16=r16+r/m16 r32=r32+r/m32	Сложение целых чисел
		+	-				-		-		+		+		+		+		+
ADC		+	-				-		-		+		+		+		+		+			Сложение с учетом флага переноса CF
XADD	r/m8,r8 r/m16,r16 r/m32,r32	+	-				-		-		+		+		+		+		-		r/mxx↔rxx; r/mxx= r/mxx+rxx	Обмен операнда­ми; сложение (с 486 проц.)
INC	r/m8 r/m16 r/m32	+	-				-		-		+		+		+		+		-		r/m8 =r/m8±1 r/m16 =r/m16±1 r/m32 =r/m32±1	Увеличение на 1
DEC		+	-				-		-		+		+		+		+		+			Уменьшение на 1
SUB	r/m8,с8 r/m16,с16 r/m32,с32 r/m8,r8 r/m16,r16 r/m32,r32 r8,r/m8 r16,r/m16 r32,r/m32	+	-				-		-		+		+		+		+		+		r/m8=r/m8-с8 r/m16=r/m16-с16 r/m32=r/m32-c32 r/m8= r/m8-r8 r/m16= r/m16-r16 r/m32= r/m32-r32 r8=r8-r/m8 r16=r16-r/m16 r32=r32-r/m32	Вычитание целых чисел
SBB		+	-				-		-		+		+		+		+		+			Вычитание с учетом флага переноса CF
CMP	r/m8,с8 r/m16,с16 r/m32,с32 r/m8,r8 r/m16,r16 r/m32,r32 r8,r/m8 r16,r/m16 r32,r/m32	+	-				-		-		+		+		+		+		+		r/m8-с8 r/m16-с16 r/m32-c32 r/m8-r8 r/m16-r16 r/m32-r32 r8-r/m8 r16-r/m16 r32-r/m32	Сравнение целых чисел
CMPXCHG	r/m8,r8 r/m16,r16 r/m32,r32	-	-				-		-		-		+		-		-		-		AL=r/m8→ r/m8=r8 AX=r/m16→r/m16=r16 EAX=r/m32→r/m32=r32	Обмен операндов по результату сравнения (с 486)
CMPXCHG8B	m64	+	-				-		-		+		+		+		+		+		EDX:EAX=m64→ m64=ECX:EBX	Сравнение и обмен 8 байт (с Pentium)
NEG	r/m8 r/m16 r/m32	U	-				-		-		U		U		+		U		+		r/m8=-r/m8 r/m16=-r/m16 r/m32=-r/m32	Изменение знака
MUL	r/m8 r/m16 r/m32	+	-				-		-		U		U		U		U		+		AX=AL*r/m8 DX:AX=AX*r/m18 EDX:EAX=EAX*r/m32	Умножение без знака
IMUL	r/m8 r/m16 r/m32 r16,r/m16 r32,r/m32 r16,r/m16,c r32,r/m32,c r16,c r32,c	U	-				-		-		U		U		U		U		U		AX=AL*r/m8 DX:AX=AX*r/m18 EDX:EAX=EAX*r/m32 r16=r16*r/m16 r32=r32*r/m32 r16=r/m16*c16 r32=r/m32*c32 r16=r16*c16 r32=r32*c32	Умножение со знаком
DIV	r/m8 r/m16 r/m32	U	-				-		-		U		U		U		U		U		AL=AX/r/m8, AH=mod AX=DX:AX/r/m18 DX=mod EAX=EDX:EAX*r/m32 EDX=mod	Деление без знака
IDIV		U	-				-		-		U		U		U		U		U			Деление со знаком
AAA	-	U	-				-		-		U		U		+		U		+		If((AL&0Fh)>9 || AF) { AH=AH+1; AL=(AL+6) & 0Fh; CF:=1; AF:=1;}	Коррекция AL после сложения двух неупакован­ных BCD чисел
AAS	-	U	-				-		-		+		+		U		+		U		if((AL&0Fh)>9)|| AF) { AH=AH-1; AL=(AL-6)& 0Fh; CF=1; AF=1;}	Коррекция AX после вычитания двух неупакован­ных BCD чисел
AAM	-	O	D				I		T		S		Z		A		P		C		AH=AL/10; AL=mod(AL/10);	Коррекция AL после умножения двух неупакован­ных BCD чисел
AAD		U			-		-		-		+		+		+		+		+		AL=AH*10+AL; AH=0;	Коррекция AL перед делением двух неупакован­ных BCD чисел
DAA		U			-		-		-		+		+		+		+		+			Коррекция AL при сложении двух упакованных BCD чисел
DAS		+			-		-		-		U		U		U		U		+			Коррекция AL при вычитании двух упакованных BCD чисел
CBW	-	-			-		-		-		-		-		-		-		-		AX=(DW)AL	Преобразование типов
CWDE	-	-			-		-		-		-		-		-		-		-		EAX=(DD)AX
CWD	-	-			-		-		-		-		-		-		-		-		DX:AX=(DD)AX
CDQ	-	-			-		-		-		-		-		-		-		-		EDX:EAX=(DQ)EAX
Логические команды																								-	-	-	-	-	-	-	-	-
NOT	r/m8 r/m16 r/m32	0			-		-		-		+		+		U		+		0		r/m8=!r/m8 r/m16=!r/m16 r/m32=!r/m32	инверсия
AND	r/m8,с8 r/m16,с16 r/m32,с32 r/m8,r8 r/m16,r16 r/m32,r32 r8,r/m8 r16,r/m16 r32,r/m32	0			-		-		-		+		+		U		+		0		r/m8=r/m8 Ф с8 r/m16=r/m16 Ф с16 r/m32=r/m32 Ф c32 r/m8= r/m8 Фr8 r/m16= r/m16 Фr16 r/m32= r/m32 Ф r32 r8=r8 Ф r/m8 r16=r16 Ф r/m16 r32=r32 Ф r/m32	Логическое умножение (И)
OR		0			-		-		-		+		+		U		+		0			Логическое сложение (ИЛИ)
XOR		0			-		-		-		+		+		U		+		0			Исключающее ИЛИ
TEST	r/m8,с8 r/m16,с16 r/m32,с32 r/m8,r8 r/m16,r16 r/m32,r32 r8,r/m8 r16,r/m16 r32,r/m32	0			-		-		-		+		+		U		+		0		r/m8&с8 r/m16&с16 r/m32&c32 r/m8&r8 r/m16&r16 r/m32&r32 r8&r/m8 r16&r/m16 r32&r/m32	Логическое умножение без сохранения результата
Сдвиговые команды
SHR	r/m8 r/m8,CL r/m8,с r/m16 r/m16,CL r/m16,c r/m32 r/m32,CL r/m32,c	+			-		-		-		+		+		U		+		+		r/m8 сдвиг 1 r/m8 сдвиг CL r/m8 сдвиг с r/m16 сдвиг 1 r/m16 сдвиг CL r/m16 сдвиг c r/m32 сдвиг 1 r/m32 сдвиг CL r/m32 сдвиг c	Логический сдвиг вправо
		+			-		-		-		+		+		U		+		+
SAR		+			-		-		-		+		+		U		+		+			Арифметический сдвиг вправо (стар­­шие биты за­полняются зна­чением знакового)
SAL SHL		+			-		-		-		-		-		-		-		+			Арифметический/ логический сдвиг влево
ROR		+			-		-		-		-		-		-		-		+			Циклический сдвиг вправо
ROL		+			-		-		-		-		-		-		-		+			Циклический сдвиг влево
RCR		+			-		-		-		-		-		-		-		+			Циклический сдвиг вправо через перенос CF
RCL		+			-		-		-		-		-		-		-		+			Циклический сдвиг влево через перенос CF
Команды управления флагами
CLC		-			0		-		-		-		-		-		-		-		CF=0;	Сброс бита переноса
CLD		-			-		0		-		-		-		-		-		-		DF=0;	Сброс бита направления
CLI		-			-		-		-		-		-		-		-		+		IF=0;	Сброс бита прерывания
CMC		-			-		-		-		-		-		-		-		1		CF=!CF;	Инверсия бита переноса
STC		-			1		-		-		-		-		-		-		-		CF=1;	Установка бита переноса
STD		-			-		1		-		-		-		-		-		-		DF=1;	Установка бита направления
STI		-			-		1		-		-		-		-		-		-		IF=1;	Установка бита прерывания
Команды прерываний
INT	3 с8	-			-		0		0		-		-		-		-		-		Отладчик Вектор c8	Программное прерывание
INTO	-	W			W		W		W		W		W		W		W		W		OF=1
IRET IRETD		W			W		W		W		W		W		W		W		W		16 бит 32 бит	Возврат из прерывания
Команды передачи управления
JMP	label r/m16 r/m32 ptr16:16 ptr16:32 m16:16 m16:32	-			-		-		-		-		-		-		-		-		метка адрес - в r/m16 near адрес - в r/m32 near far far far far	Безусловный переход. При рабо­те в Windows используется в основном внутрисегментный переход (NEAR) в пределах 32-битного сегмента.
CALL	label r/m ptr	-			-		-		-		-		-		-		-		-			Вызов процедуры
RET	- c16	-			-		-		-		-		-		-		-		-		Удалить с байт из стека	Возврат из процедуры
LOOP	label	-			-		-		-		-		-		-		-		-		CX=CX-1; If(CX!=0) EIP=label;	Переход если CX!=0
LOOPE LOOPZ	label	-			-		-		-		-		-		-		-		-		CX=CX-1; If(CX!=0 & ZF=1) EIP=label;	Переход если равно ZF=1
LOOPNE LOOPNZ	label	-			-		-		-		-		-		-		-		-		CX=CX-1; If(CX!=0 & ZF=0) EIP=label;	Переход если не равно ZF=0
JCXZ	label	-			-		-		-		-		-		-		-		-		if(CX==0) EIP=label;	Переход если CX=0
JC	label	-			-		-		-		-		-		-		-		-		if(CF==1) EIP=label;	Переход при переносе
JNC	label	-			-		-		-		-		-		-		-		-		if(CF==0) EIP=label;	Переход при отсутствии переноса
JS	label	-			-		-		-		-		-		-		-		-		if(SF==1) EIP=label;	Переход при отрица­тельном резуль­тате
JNS	label	-			-		-		-		-		-		-		-		-		if(SF==0) EIP=label;	Переход при положи­тельном результате
JE JZ	label	-			-		-		-		-		-		-		-		-		if(ZF==1) EIP=label;	Переход при нулевом результате
JNE JNZ	label	-			-		-		-		-		-		-		-		-		if(ZF==0) EIP=label;	Переход при ненуле­вом результате
JP JPE	label	-			-		-		-		-		-		-		-		-		if(PF==1) EIP=label;	Переход, если PF=1
JNP JPO	label	-			-		-		-		-		-		-		-		-		if(PF==0) EIP=label;	Переход, если PF=0
JO	label	-			-		-		-		-		-		-		-		-		if(OF==1) EIP=label;	Переход при переполнении
JNO	label	-			-		-		-		-		-		-		-		-		if(OF==0) EIP=label;	Переход при отсут­ствии переполнения
Беззнаковые переходы
JB JNAE	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(CF==1)//m1<m2 EIP=label;	Переход если ниже операнд1<операнд2
JBE JNA	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(CF==1|ZF==1) //m1<=m2 EIP=label;	Переход если ниже или равно операнд1<=операнд2
JAE JNB	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(CF==0) //m1>=m2 EIP=label;	Переход если выше или равно операнд1>=операнд2
JA/JNBE	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(CF==0&ZF==0) //m1>m2 EIP=label;	Переход если выше операнд1>операнд2
Знаковые переходы
JL JNGE	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(SF^OF)//m1<m2 EIP=label;	Переход если меньше операнд1<операнд2
JLE JNG	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if((SF^OF) | ZF) //m1<=m2 EIP=label;	Переход если меньше или равно операнд1<=операнд2
JGE JNL	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(SF==OF) //m1>=m2 EIP=label;	Переход если больше или равно операнд1>=операнд2
JG JNLE	label	-			-		-		-		-		-		-		-		-		cmp m1,m2 if(SF==OF &!ZF) //m1>m2 EIP=label;	Переход если больше операнд1>операнд2
Команды поддержки языков высокого уровня
ENTER	c16,0 c16,1 c16,c8	-			-		-		-		-		-		-		-		-		PUSH EBP MOV EBP, ESP	Подготовка стека при входе в про­цедуру. Константа с16 указывает ко­ли­чество байт, ре­зервируемых в сте­ке для локаль­ных идентификаторов, константа 0, 1,…31 определя­ется вло­женностью проце­дур
LEAVE	-	-			-		-		-		-		-		-		-		-		POP EBP	Приведение сте­ка в исходное состояние
BOUND	r16, m16&16 r32, m32&32	-			-		-		-		-		-		-		-		-		m16<r16<m16&16 m32<r16<m32&32	Проверка индекса массива
Команды синхронизации процессора
HLT	-	-			-		-		-		-		-		-		-		-			Остановка про­цес­сора до внешнего прерывания
LOCK	-	-			-		-		-		-		-		-		-		-