https://sysprog.ru/post/komanda-cmp https://flatassembler.net/docs.php?article=manual http://www.club155.ru/x86cmd/MUL ====== FASM ====== ===== Data sizes, definitions, Constants and labels ===== ^Operator ^Bits ^Bytes^ |byte|8|1| |word|16|2| |dword|32|4| |fword|48|6| |pword|48|6| |qword|64|8| |tbyte|80|10| |tword|80|10| |dqword|128|16| |xword|128|16| |qqword|256|32| |yword|256|32| |dqqword|512|64| |zword|512|64| ==== Definitions ==== ^Size (bytes)^Define data^Reserve data^ |1|db\\ file|rb| |2|dw\\ du|rw| |4|dd|rd| |6|dp\\ df|rp\\ rf| |8|dq|rq| |10|dt|rt| db 1,2,3 db 'abc' dp 1234:5678 df 1234:5678 dt 70000:80000 dt 2670.0 db 5 dup (1,2) file 'data.bin':10h,4 ==== Constants and labels ==== count = 17 mov cx,count - char db 224 mov bx,char mov dl,[char] mov ax,[char] - error mov ax, word [char] label wchar word at char mov ax,[wchar] .label2 (wchar.label2) @@ @r @f ---- ===== Registers ===== ^Type^Bits^Registers^^^^^^^^ |General|8|al|cl|dl|bl|ah|ch|dh|bh| |:::|16|ax|cx|dx|bx|sp|bp|si|di| |:::|32|eax|ecx|edx|ebx|esp|ebp|esi|edi| |Segment|16|es|cs|ss|ds|fs|gs| |Control|32|cr0| |cr2|cr3|cr4| |Debug|32|dr0|dr1|dr2|dr3| | |dr6|dr7| |FPU|80|st0|st1|st2|st3|st4|st5|st6|st7| |MMX|64|mm0|mm1|mm2|mm3|mm4|mm5|mm6|mm7| |SSE|128|xmm0|xmm1|xmm2|xmm3|xmm4|xmm5|xmm6|xmm7| |AVX|256|ymm0|ymm1|ymm2|ymm3|ymm4|ymm5|ymm6|ymm7| |AVX-512|512|zmm0|zmm1|zmm2|zmm3|zmm4|zmm5|zmm6|zmm7| |Opmask|64|k0|k1|k2|k3|k4|k5|k6|k7| |Bounds|128|bnd0|bnd1|bnd2|bnd3| ===== Numerical expressions ===== 100110101b 123456701233o 0x01234567890ABCDEF 01234567890ABCDEF$ 01234567890ABCDEFh "234567" $ (current address) $$ (base address of current addressing space) % (number of current repeat in parts of code) %t (current time stamp) 1.0, 1E0 and 1f define the same floating point value ^Priority^Operators^ |0|+ -| |1|* /| |2|mod| |3|and or xor| |4|shl shr| |5|not| |6|bsf bsr| |7|rva plt| ===== Instruction set ===== ==== MOV ==== Processor : 8086+ \\ Flags : No mov bx,ax ; general register to general register mov [char],al ; general register to memory mov bl,[char] ; memory to general register mov dl,32 ; immediate value to general register mov [char],32 ; immediate value to memory mov ax,ds ; segment register to general register mov [bx],ds ; segment register to memory mov ds,ax ; general register to segment register mov ds,[bx] ; memory to segment register mov eax,cr0 ; control register to general register mov cr3,ebx ; general register to control register ==== XCHG ==== Processor : 80386+ \\ Flags : No xchg ax,bx ; swap two general registers xchg al,[char] ; swap register with memory ==== PUSH ==== Processor : 8086+ \\ Flags : No push ax ; store general register push es ; store segment register pushw [bx] ; store word in memory push 1000h ; store immediate value pushd [ax] ; store double word push ax bx cx dx; pusha ; store general registers pushaw pushad ==== POP ==== Processor : 8086+ \\ Flags : No pop bx ; restore general register pop ds ; restore segment register popw [si] ; restore memory ==== CWD ==== Processor : 8086+ \\ Flags : No cwd ; convert AX to DX:AX using the sign ==== CDQ ==== Processor : 80386+ \\ Flags : No cdq ; convert EAX to EDX:EAX using the sign ==== CBW ==== Processor : 8086+ \\ Flags : No cbw ; convert AL to AX using the sign ==== CWDE ==== Processor : 80386+ \\ Flags : No cwde ; convert AX to EAX using the sign ==== MOVSX ==== Processor : 80386+ \\ Flags : No movsx ax,al ; copy byte register to word register with sign movsx edx,dl ; byte register to double word register movsx eax,ax ; word register to double word register movsx ax,byte [bx] ; byte memory to word register movsx edx,byte [bx] ; byte memory to double word register movsx eax,word [bx] ; word memory to double word register ==== MOVZX ==== Processor : 80386+ \\ Flags : No movsx ax,al ; copy byte register to word register without sign movsx edx,dl ; byte register to double word register movsx eax,ax ; word register to double word register movsx ax,byte [bx] ; byte memory to word register movsx edx,byte [bx] ; byte memory to double word register movsx eax,word [bx] ; word memory to double word register ==== ADD, SUB ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, CF, PF add ax,bx ; add register to register sub ax,bx ; subtract register from register add ax,[si] ; add memory to register add [di],al ; add register to memory add al,48 ; add immediate value to register add [char],48 ; add immediate value to memory ==== ADС, SBB ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, CF, PF adс ax,bx ; add register to register with CF sbb ax,bx ; subtract register from register with CF adс ax,[si] ; add memory to register adс [di],al ; add register to memory adс al,48 ; add immediate value to register adс [char],48 ; add immediate value to memory ==== INС, DEC ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, PF inc ax ; increment register by one dec ax ; decrement register by one inc byte [bx] ; increment memory by one ==== CMP ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, CF, PF cmp ax,bx ; compare register to register (like a SUB) ==== NEG ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, PF, CF neg ax ; ax = 0 - ax ==== XADD ==== Processor : 80486+ \\ Flags : OF, SF, ZF, AF, PF, CF xadd eax, ebx ; ebx = eax & eax = eax + ebx ==== MUL ==== Processor : 8086+ \\ Flags : OF, CF MUL r/m8 ; AX = AL * r/m8 (8086+) MUL r/m16 ; DX:AX = AX * r/m16 (8086+) MUL r/m32 ; EDX:EAX = EAX * r/m32 (80386+) ==== IMUL ==== Processor : 8086+, 80386+ \\ Flags : OF, CF IMUL r/m8 ; AX=AL*r/m8 (8086+) IMUL r/m16 ; DX:AX=AX*r/m16 (8086+) IMUL r/m32 ; EDX:EAX=EAX*r/m32 (80386+) IMUL r16,r/m16 ; r16=r16*r/m16 (80386+) IMUL r32,r/m32 ; r32=r32*r/m32 (80386+) IMUL r16,r/m16,imm8 ; r16=r/m16*(знакорасширенное imm8) (80186+) IMUL r32,r/m32,imm8 ; r32=r/m32*(знакорасширенное imm8) (80386+) IMUL r16,imm8 ; r16=r16*(знакорасширенное imm8) (80186+) IMUL r32,imm8 ; r32=r32*(знакорасширенное imm8) (80386+) IMUL r16,r/m16,imm16 ; r16=r/m16*(знакорасширенное imm16) (80186+) IMUL r32,r/m32,imm16 ; r32=r/m32*(знакорасширенное imm16) (80386+) IMUL r16,imm16 ; r16=r16*imm16 (80186+) IMUL r32,imm32 ; r32=r32*imm32 (80386+) ==== DIV ==== Processor : 8086+ \\ Flags : no DIV AL,r/m8 ; Беззнаковое деление AX на r/m8, частное помещается в AL, остаток от деления - в AH ; (8086+) DIV AX,r/m16 ; Беззнаковое деление DX:AX на r/m16, частное помещается в AX, остаток от деления - в DX ; (8086+) DIV EAX,r/m32 ; Беззнаковое деление EDX:EAX на r/m32, частное помещается в EAX, ; остаток от деления - в EDX (80386+) ==== IDIV ==== Processor : 8086+ \\ Flags : no IDIV AL,r/m8 ; Знаковое деление AX на r/m8, частное помещается в AL, остаток от деления - в AH ; (8086+) IDIV AX,r/m16 ; Знаковое деление DX:AX на r/m16, частное помещается в AX, остаток от деления - в DX ; (8086+) IDIV EAX,r/m32 ; Знаковое деление EDX:EAX на r/m32, частное помещается в EAX, ; остаток от деления - в EDX (80386+) ==== DAA ==== Processor : 8086+ \\ Flags : SF, ZF, AF, PF, CF DAA ; Десятичная коррекция AL после сложения ==== DAS ==== Processor : 8086+ \\ Flags : SF, ZF, AF, PF, CF DAS ; Десятичная коррекция AL после вычитания ==== AAA ==== Processor : 8086+ \\ Flags : AF, CF AAA ; ASCII коррекция AL после сложения ==== AAS ==== Processor : 8086+ \\ Flags : AF, CF AAS ; ASCII коррекция AL после вычитания ==== AAM ==== Processor : 8086+ \\ Flags : SF, ZF, PF AAM ; ASCII коррекция AX после умножения AAM imm8 ; ASCII коррекция AX после умножения по числу, базирующемуся на imm8 ==== AAD ==== Processor : 8086+ \\ Flags : SF, ZF, PF AAD ; ASCII коррекция AX перед делением AAD imm8 ; ASCII коррекция AX перед делением по числу, базирующемуся на imm8 ==== NOT ==== Processor : 8086+ \\ Flags : no NOT r/m8 ; r/m8 = NOT r/m8 (8086+) NOT r/m16 ; r/m16 = NOT r/m16 (8086+) NOT r/m32 ; r/m32 = NOT r/m32 (80386+) ==== AND ==== Processor : 8086+ \\ Flags : OF, SF, ZF, PF, CF 20 /r AND r/m8,r8 ; r/m8 AND r8 (8086+) 21 /r AND r/m16,r16 ; r/m16 AND r16 (8086+) 21 /r AND r/m32,r32 ; r/m32 AND r32 (80386+) 22 /r AND r8,r/m8 ; r8 AND r/m8 (8086+) 23 /r AND r16,r/m16 ; r16 AND r/m16 (8086+) 23 /r AND r32,r/m32 ; r32 AND r/m32 (80386+) 24 ib AND AL,imm8 ; АL AND imm8 (8086+) 25 iw AND AX,imm16 ; AX AND imm16 (8086+) 25 id AND EAX,imm32 ; EAX AND imm32 (80386+) 80 /4 ib AND r/m8,imm8 ; r/m8 AND imm8 (8086+) 81 /4 iw AND r/m16,imm16 ; r/m16 AND imm16 (8086+) 81 /4 id AND r/m32,imm32 ; r/m32 AND imm32 (80386+) 83 /4 ib AND r/m16,imm8 ; r/m16 AND imm8 (знакорасшир.) (8086+) 83 /4 ib AND r/m32,imm8 ; r/m32 AND imm8 (знакорасшир.) (80386+) ==== OR ==== Processor : 8086+ \\ Flags : OF, SF, ZF, PF, CF 0C ib OR AL,imm8 ; AL = AL OR imm8 (8086+) 0D iw OR AX,imm16 ; AX = AX OR imm16 (8086+) 0D id OR EAX,imm32 ; EAX = EAX OR imm32 (80386+) 80 /1 ib OR r/m8,imm8 ; r/m8 = r/m8 OR imm8 (8086+) 81 /1 iw OR r/m16,imm16 ; r/m16 = r/m16 OR imm16 (8086+) 81 /1 id OR r/m32,imm32 ; r/m32 = r/m32 OR imm32 (80386+) 83 /1 ib OR r/m16,imm8 ; r/m16 = r/m16 OR (Знакорасширенное imm8) (8086+) 83 /1 ib OR r/m32,imm8 ; r/m32 = r/m32 OR (Знакорасширенное imm8) (80386+) 08 /r OR r/m8,r8 ; r/m8 = r/m8 OR r8 (8086+) 09 /r OR r/m16,r16 ; r/m16 = r/m16 OR r16 (8086+) 09 /r OR r/m32,r32 ; r/m32 = r/m32 OR r32 (80386+) 0A /r OR r8,r/m8 ; r8 = r8 OR r/m8 (8086+) 0B /r OR r16,r/m16 ; r16 = r16 OR r/m16 (8086+) 0B /r OR r32,r/m32 ; r32 = r32 OR r/m32 (80386+) ==== XOR ==== Processor : 8086+ \\ Flags : OF, SF, ZF, PF, CF 34 ib XOR AL,imm8 ; AL = AL XOR imm8 (8086+) 35 iw XOR AX,imm16 ; AX = AX XOR imm16 (8086+) 35 id XOR EAX,imm32 ; EAX = EAX XOR imm32 (80386+) 80 /6 ib XOR r/m8,imm8 ; r/m8 = r/m8 XOR imm8 (8086+) 81 /6 iw XOR r/m16,imm16 ; r/m16 = r/m16 XOR imm16 (8086+) 81 /6 id XOR r/m32,imm32 ; r/m32 = r/m32 XOR imm32 (80386+) 83 /6 ib XOR r/m16,imm8 ; r/m16 = r/m16 XOR (Знакорасширенное imm8) (8086+) 83 /6 ib XOR r/m32,imm8 ; r/m32 = r/m32 XOR (Знакорасширенное imm8) (80386+) 30 /r XOR r/m8,r8 ; r/m8 = r/m8 XOR r8 (8086+) 31 /r XOR r/m16,r16 ; r/m16 = r/m16 XOR r16 (8086+) 31 /r XOR r/m32,r32 ; r/m32 = r/m32 XOR r32 (80386+) 32 /r XOR r8,r/m8 ; r8 = r8 XOR r/m8 (8086+) 33 /r XOR r16,r/m16 ; r16 = r16 XOR r/m16 (8086+) 33 /r XOR r32,r/m32 ; r32 = r32 XOR r/m32 (80386+) ==== BT ==== Processor : 80386+ \\ Flags : CF 0F A3 BT r/m16,r16 ; Сохранить выбираемый r16 бит r/m16 в CF 0F A3 BT r/m32,r32 ; Сохранить выбираемый r32 бит r/m32 в CF 0F BA /4 ib BT r/m16,imm8 ; Сохранить выбираемый imm8 бит r/m16 в CF 0F BA /4 ib BT r/m32,imm8 ; Сохранить выбираемый imm8 бит r/m32 в CF ==== BTS ==== Processor : 80386+ \\ Flags : CF 0F A3 BT r/m16,r16 ; Сохранить выбираемый r16 бит r/m16 в CF 0F AB BTS r/m16,r16 ; Выбрать по r16 бит из r/m16 в CF установить этот бит 0F AB BTS r/m32,r32 ; Выбрать по r32 бит из r/m32 в CF установить этот бит 0F BA /5 ib BTS r/m16,imm8 ; Выбрать по imm8 бит из r/m16 в CF установить этот бит 0F BA /5 ib BTS r/m32,imm8 ; Выбрать по imm8 бит из r/m32 в CF установить этот бит ==== BTR ==== Processor : 80386+ \\ Flags : CF 0F B3 BTR r/m16,r16 ; Выбрать по r16 бит из r/m16 в CF сбросить этот бит 0F B3 BTR r/m32,r32 ; Выбрать по r32 бит из r/m32 в CF сбросить этот бит 0F BA /6 ib BTR r/m16,imm8 ; Выбрать по imm8 бит из r/m16 в CF сбросить этот бит 0F BA /6 ib BTR r/m32,imm8 ; Выбрать по imm8 бит из r/m32 в CF сбросить этот бит ==== BTC ==== Processor : 80386+ \\ Flags : CF 0F BB BTC r/m16,r16 ; Выбрать по r16 бит из r/m16 в CF инвертировать этот бит 0F BB BTC r/m32,r32 ; Выбрать по r32 бит из r/m32 в CF инвертировать этот бит 0F BA /7 ib BTC r/m16,imm8 ; Выбрать по imm8 бит из r/m16 в CF инвертировать этот бит 0F BA /7 ib BTC r/m32,imm8 ; Выбрать по imm8 бит из r/m32 в CF инвертировать этот бит ==== BSF ==== Processor : 80386+ \\ Flags : ZF 0F BC BSF r16,r/m16 ; Сканирование битов r/m16 вперед 0F BC BSF r32,r/m32 ; Сканирование битов r/m32 вперед ==== BSR ==== Processor : 80386+ \\ Flags : ZF 0F BD BSR r16,r/m16 ; Сканирование битов r/m16 назад 0F BD BSR r32,r/m32 ; Сканирование битов r/m32 назад ==== SHL, SHR, SAL, SAR ==== Processor : 8086+ \\ Flags : SF, ZF, PF, CF D0 /4 SAL r/m8,1 ; Арифметический сдвиг r/m8 влево (r/m8 = r/m8 * 2) (8086+) D2 /4 SAL r/m8,CL ; Арифметический сдвиг r/m8 влево (r/m8 = r/m8 * 2^CL) (8086+) C0 /4 ib SAL r/m8,imm8 ; Арифметический сдвиг r/m8 влево (r/m8 = r/m8 * 2^imm8) (8086+) D1 /4 SAL r/m16,1 ; Арифметический сдвиг r/m16 влево (r/m16 = r/m16 * 2) (8086+) D3 /4 SAL r/m16,CL ; Арифметический сдвиг r/m16 влево (r/m16 = r/m16 * 2^CL) (8086+) C1 /4 ib SAL r/m16,imm8 ; Арифметический сдвиг r/m16 влево (r/m16 = r/m16 * 2^imm8) (8086+) D1 /4 SAL r/m32,1 ; Арифметический сдвиг r/m32 влево (r/m32 = r/m32 * 2) (80386+) D3 /4 SAL r/m32,CL ; Арифметический сдвиг r/m32 влево (r/m32 = r/m32 * 2^CL) (80386+) C1 /4 ib SAL r/m32,imm8 ; Арифметический сдвиг r/m32 влево (r/m32 = r/m32 * 2^imm8) (80386+) D0 /7 SAR r/m8,1 ; Арифметический сдвиг r/m8 вправо (r/m8 = sign(r/m8) * r/m8 / 2) (8086+) D2 /7 SAR r/m8,CL ; Арифметический сдвиг r/m8 вправо (r/m8 = sign(r/m8) * r/m8 / 2^CL) (8086+) C0 /7 ib SAR r/m8,imm8 ; Арифметический сдвиг r/m8 вправо (r/m8 = sign(r/m8) * r/m8 / 2^imm8) (8086+) D1 /7 SAR r/m16,1 ; Арифметический сдвиг r/m16 вправо (r/m16 = sign(r/m16) * r/m16 / 2) (8086+) D3 /7 SAR r/m16,CL ; Арифметический сдвиг r/m16 вправо (r/m16 = sign(r/m16) * r/m16 / 2^CL) C1 /7 ib SAR r/m16,imm8 ; Арифметический сдвиг r/m16 вправо (r/m16 = sign(r/m16) * r/m16 / 2^imm8) (8086+) D1 /7 SAR r/m32,1 ; Арифметический сдвиг r/m32 вправо (r/m32 = sign(r/m32) * r/m32 / 2) (80386+) D3 /7 SAR r/m32,CL ; Арифметический сдвиг r/m32 вправо (r/m32 = sign(r/m32) * r/m32 / 2^CL) (80386+) C1 /7 ib SAR r/m32,imm8 ; Арифметический сдвиг r/m32 вправо (r/m32 = sign(r/m32) * r/m32 / 2^imm8) (80386+) D0 /4 SHL r/m8,1 ; Логический сдвиг r/m8 влево (r/m8 = r/m8 * 2) D2 /4 SHL r/m8,CL ; Логический сдвиг r/m8 влево (r/m8 = r/m8 * 2^CL) (8086+) C0 /4 ib SHL r/m8,imm8 ; Логический сдвиг r/m8 влево (r/m8 = r/m8 * 2^imm8) (8086+) D1 /4 SHL r/m16,1 ; Логический сдвиг r/m16 влево (r/m16 = r/m16 * 2) (8086+) D3 /4 SHL r/m16,CL ; Логический сдвиг r/m16 влево (r/m16 = r/m16 * 2^CL) (8086+) C1 /4 ib SHL r/m16,imm8 ; Логический сдвиг r/m16 влево (r/m16 = r/m16 * 2^imm8) (8086+) D1 /4 SHL r/m32,1 ; Логический сдвиг r/m32 влево (r/m32 = r/m32 * 2) (80386+) D3 /4 SHL r/m32,CL ; Логический сдвиг r/m32 влево (r/m32 = r/m32 * 2^CL) (80386+) C1 /4 ib SHL r/m32,imm8 ; Логический сдвиг r/m32 влево (r/m32 = r/m32 * 2^imm8) (80386+) D0 /5 SHR r/m8,1 ; Логический сдвиг r/m8 вправо (r/m8 = |r/m8| / 2) (8086+) D2 /5 SHR r/m8,CL ; Логический сдвиг r/m8 вправо (r/m8 = |r/m8| / 2^CL) C0 /5 ib SHR r/m8,imm8 ; Логический сдвиг r/m8 вправо (r/m8 = |r/m8| / 2^imm8) (8086+) D1 /5 SHR r/m16,1 ; Логический сдвиг r/m16 вправо (r/m16 = |r/m16| / 2) (8086+) D3 /5 SHR r/m16,CL ; Логический сдвиг r/m16 вправо (r/m16 = |r/m16| / 2^CL) (8086+) C1 /5 ib SHR r/m16,imm8 ; Логический сдвиг r/m16 вправо (r/m16 = |r/m16| / 2^imm8) (8086+) D1 /5 SHR r/m32,1 ; Логический сдвиг r/m32 вправо (r/m32 = |r/m32| / 2)(80386+) D3 /5 SHR r/m32,CL ; Логический сдвиг r/m32 вправо (r/m32 = |r/m32| / 2^CL) (80386+) C1 /5 ib SHR r/m32,imm8 ; Логический сдвиг r/m32 вправо (r/m32 = |r/m32| / 2^imm8) (80386+) ==== SHLD, SHRD ==== Processor : 80386+ \\ Flags : SF, ZF, PF, CF OF A4 SHLD r/m16,r16,imm8 ; Сдвинуть r/m16 влево на imm8 бит, заполнив сдвинутые биты битами из r16 OF A4 SHLD r/m32,r32,imm8 ; Сдвинуть r/m32 влево на imm8 бит, заполнив сдвинутые биты битами из r32 OF A5 SHLD r/m16,r16,CL ; Сдвинуть r/m16 влево на CL бит, заполнив сдвинутые биты битами из r16 OF A5 SHLD r/m32,r32,CL ; Сдвинуть r/m32 влево на CL бит, заполнив сдвинутые биты битами из r32 OF AC SHRD r/m16,r16,imm8 ; Сдвинуть r/m16 вправо на imm8 бит, заполнив сдвинутые биты битами из r16 OF AC SHRD r/m32,r32,imm8 ; Сдвинуть r/m32 вправо на imm8 бит, заполнив сдвинутые биты битами из r32 OF AD SHRD r/m16,r16,CL ; Сдвинуть r/m16 вправо на CL бит, заполнив сдвинутые биты битами из r16 OF AD SHRD r/m32,r32,CL ; Сдвинуть r/m32 вправо на CL бит, заполнив сдвинутые биты битами из r32 ==== RCR, RCL, ROL, ROR ==== Processor : 8086+ \\ Flags : OF, CF D0 /2 RCL r/m8,1 ; Сдвинуть по кругу влево на 1 бит 9 бит (CF, r/m8) (8086+) D2 /2 RCL r/m8,CL ; Сдвинуть по кругу влево на CL бит 9 бит (CF, r/m8)(8086 C0 /2 ib RCL r/m8,imm8 ; Сдвинуть по кругу влево на imm8 бит 9 бит (CF, r/m8) (80286+) D1 /2 RCL r/m16,1 ; Сдвинуть по кругу влево на 1 бит 17 бит (CF, r/m16) (8086+) D3 /2 RCL r/m16,CL ; Сдвинуть по кругу влево на CL бит 17 бит (CF, r/m16) (8086+) C1 /2 ib RCL r/m16,imm8 ; Сдвинуть по кругу влево на imm8 бит 17 бит (CF, r/m16) (80286+) D1 /2 RCL r/m32,1 ; Сдвинуть по кругу влево на 1 бит 33 бита (CF, r/m32) (80386+) D3 /2 RCL r/m32,CL ; Сдвинуть по кругу влево на CL бит 33 бита (CF, r/m32) (80386+) C1 /2 ib RCL r/m32,imm8 ; Сдвинуть по кругу влево на imm8 бит 33 бита (CF, r/m32) (80386+) D0 /3 RCR r/m8,1 ; Сдвинуть по кругу вправо на 1 бит 9 бит (CF, r/m8) (8086+) D2 /3 RCR r/m8,CL ; Сдвинуть по кругу вправо на CL бит 9 бит (CF, r/m8) (8086+) C0 /3 ib RCR r/m8,imm8 ; Сдвинуть по кругу вправо на imm8 бит 9 бит (CF, r/m8) (80286+) D1 /3 RCR r/m16,1 ; Сдвинуть по кругу вправо на 1 бит 17 бит (CF, r/m16) (8086+) D3 /3 RCR r/m16,CL ; Сдвинуть по кругу вправо на CL бит 17 бит (CF, r/m16) (8086+) C1 /3 ib RCR r/m16,imm8 ; Сдвинуть по кругу вправо на imm8 бит 17 бит (CF, r/m16) (80286+) D1 /3 RCR r/m32,1 ; Сдвинуть по кругу вправо на 1 бит 33 бита (CF, r/m32) (80386+) D3 /3 RCR r/m32,CL ; Сдвинуть по кругу вправо на CL бит 33 бита (CF, r/m32) (80386+) C1 /3 ib RCR r/m32,imm8 ; Сдвинуть по кругу вправо на imm8 бит 33 бита (CF, r/m32) (80386+) D0 /0 ROL r/m8,1 ; Сдвинуть по кругу влево на 1 бит 8 бит (r/m8) (8086+) D2 /0 ROL r/m8,CL ; Сдвинуть по кругу влево на CL бит 8 бит (r/m8) (8086+) C0 /0 ib ROL r/m8,imm8 ; Сдвинуть по кругу влево на imm8 бит 8 бит (r/m8) (80286+) D1 /0 ROL r/m16,1 ; Сдвинуть по кругу влево на 1 бит 16 бит (r/m16) (8086+) D3 /0 ROL r/m16,CL ; Сдвинуть по кругу влево на CL бит 16 бит (r/m16) (8086+) C1 /0 ib ROL r/m16,imm8 ; Сдвинуть по кругу влево на imm8 бит 16 бит (r/m16) (80286+) D1 /0 ROL r/m32,1 ; Сдвинуть по кругу влево на 1 бит 32 бита (r/m32) (80386+) D3 /0 ROL r/m32,CL ; Сдвинуть по кругу влево на CL бит 32 бита (r/m32) (80386+) C1 /0 ib ROL r/m32,imm8 ; Сдвинуть по кругу влево на imm8 бит 32 бита (r/m32) (80386+) D0 /1 ROR r/m8,1 ; Сдвинуть по кругу вправо на 1 бит 8 бит (r/m8) (8086+) D2 /1 ROR r/m8,CL ; Сдвинуть по кругу вправо на CL бит 8 бит (r/m8) (8086+) C0 /1 ib ROR r/m8,imm8 ; Сдвинуть по кругу вправо на imm8 бит 8 бит (r/m8) (80286+) D1 /1 ROR r/m16,1 ; Сдвинуть по кругу вправо на 1 бит 16 бит (r/m16) (8086+) D3 /1 ROR r/m16,CL ; Сдвинуть по кругу вправо на CL бит 16 бит (r/m16) (8086+) C1 /1 ib ROR r/m16,imm8 ; Сдвинуть по кругу вправо на imm8 бит 16 бит (r/m16) (80286+) D1 /1 ROR r/m32,1 ; Сдвинуть по кругу вправо на 1 бит 32 бита (r/m32) (80386+) D3 /1 ROR r/m32,CL ; Сдвинуть по кругу вправо на CL бит 32 бита (r/m32) (80386+) C1 /1 ib ROR r/m32,imm8 ; Сдвинуть по кругу вправо на imm8 бит 32 бита (r/m32) (80386+) ==== TEST ==== Processor : 8086+ \\ Flags : OF, SF, ZF, PF A8 ib TEST AL,imm8 ; Установить флаги SF, ZF, PF по результату операции imm8 AND AL (8086+) A9 iw TEST AX,imm16 ; Установить флаги SF, ZF, PF по результату операции imm16 AND AX (8086+) A9 id TEST EAX,imm32 ; Установить флаги SF, ZF, PF по результату операции imm32 AND EAX (80386+) F6 /0 ib TEST r/m8,imm8 ; Установить флаги SF, ZF, PF по результату операции imm8 AND r/m8 (8086+) F7 /0 iw TEST r/m16,imm16 ; Установить флаги SF, ZF, PF по результату операции imm16 AND r/m16 (8086+) F7 /0 id TEST r/m32,imm32 ; Установить флаги SF, ZF, PF по результату операции imm32 AND r/m32 (80386+) 84 /r TEST r/m8,r8 ; Установить флаги SF, ZF, PF по результату операции r/m8 AND r8 (8086+) 85 /r TEST r/m16,r16 ; Установить флаги SF, ZF, PF по результату операции r/m16 AND r168086 85 /r TEST r/m32,r32 ; Установить флаги SF, ZF, PF по результату операции r/m32 AND r32 (80386+) ==== BSWAP ==== Processor : 80486+ \\ Flags : no 0F C8+rd BSWAP r32 ; Перестановка байтов в 32-битном регистре ==== JMP ==== Processor : 8086+ \\ Flags : no EB cb JMP rel8 ; Короткий переход, 8-битное знаковое смещение задается относительно следующей команды (8086+) E9 cw JMP rel16 ; Ближний переход, 16-битное знаковое смещение задается относительно следующей команды (8086+) E9 cd JMP rel32 ; Ближний переход, 32-битное знаковое смещение задается относительно следующей команды (Intel386+) FF /4 JMP r/m16 ; Ближний косвенный переход, r/m16 задает абсолютное смещение адреса назначения (8086+) FF /4 JMP r/m32 ; Ближний косвенный переход, r/m32 задает абсолютное смещение адреса назначения (Intel386+) EA cd JMP ptr16:16 ; Дальний межсегментный переход, абсолютный адрес назначения задается 4-байтным непосредственным операндом ptr16:16 (8086+) EA cp JMP ptr16:32 ; Дальний межсегментный переход, абсолютный адрес назначения задается 6-байтным непосредственным операндом ptr16:32 (Intel386+) FF /5 JMP m16:16 ; Дальний косвенный межсегментный переход, абсолютный адрес назначения задается 4-байтным операндом в ячейке памяти m16:16 (8086+) FF /5 JMP m16:32 ; Дальний косвенный межсегментный переход, абсолютный адрес назначения задается 6-байтным операндом в ячейке памяти m16:32 (Intel386+) ==== CALL ==== Processor : 8086+ \\ Flags : no E8 cw CALL rel16 ; Ближний вызов, 16-битное смещение указывается относительно следующей команды (8086+) E8 cd CALL rel32 ; Ближний вызов, 32-битное смещение указывается относительно следующей команды (Intel386+) FF /2 CALL r/m16 ; Ближний вызов, 2-байтный адрес указывается в r/m16 (8086+) FF /2 CALL r/m32 ; Ближний вызов, 4-байтный адрес указывается в r/m32 (Intel386+) 9A cd CALL ptr16:16 ; Дальний вызов, указывается 4-байтный непосредственный адрес (8086+) 9A cp CALL ptr16:32 ; Дальний вызов, указывается 6-байтный непосредственный адрес (Intel386+) FF /3 CALL m16:16 ; Дальний вызов по адресу, указанному в операнде в памяти (8086+) FF /3 CALL m16:32 ; Дальний вызов по адресу, указанному в операнде в памяти (Intel386+) ==== RET, RETN, RETF ==== Processor : 8086+ \\ Flags : no C3 RET ; Ближний возврат из процедуры (8086+) CB RET ; Дальний возврат из процедуры (8086+) C2 iw RET imm16 ; Ближний возврат из процедуры с освобождением imm16 байт в стеке (8086+) CA iw RET imm16 ; Дальний возврат из процедуры с освобождением imm16 байт в стеке (8086+) ==== IRET, IRETD ==== Processor : 8086+ \\ Flags : OF, DF, IF, TF, SF, ZF, AF, PF, CF CF IRET ; Возврат из прерывания при 16-битном размере операнда (8086+) CF IRETD ; Возврат из прерывания при 32-битном размере операнда (80386+) ==== JA, JAE, JB, JBE, JC, JCXZ, JECXZ, JE, JZ, JG, JGE, JL, JLE, JNA, JNAE, JNB, JNBE, JNC, JNE, JNG, JNGE, JNL, JNLE, JNO, JNP, JNS, JNZ, JO, JP, JPE, JPO, JS ==== Processor : 8086+ \\ Flags : OF, DF, IF, TF, SF, ZF, AF, PF, CF 77 cb JA rel8 ; Короткий переход, если выше (CF=0 и ZF=0) 8086 73 cb JAE rel8 ; Короткий переход, если выше или равно (CF=0)8086 72 cb JB rel8 ; Короткий переход, если ниже (CF=1)8086 76 cb JBE rel8 ; Короткий переход, если ниже или равно (CF=1 или ZF=1)8086 72 cb JC rel8 ; Короткий переход, если перенос (CF=1)8086 E3 cb JCXZ rel8 ; Короткий переход, если CX=0 8086 E3 cb JECXZ rel8 ; Короткий переход, если ECX=0 Intel386 74 cb JE rel8 ; Короткий переход, если равно (ZF=1) 8086 74 cb JZ rel8 ; Короткий переход, если нуль (ZF=1) 8086 7F cb JG rel8 ; Короткий переход, если больше (ZF=0 и SF=OF) 8086 7D cb JGE rel8 ; Короткий переход, если больше или равно (SF=OF) 8086 7C cb JL rel8 ; Короткий переход, если меньше (SF<>OF) 8086 7E cb JLE rel8 ; Короткий переход, если меньше или равно (ZF=1 или SF<>OF) 8086 76 cb JNA rel8 ; Короткий переход, если не выше (CF=1 или ZF=1) 8086 72 cb JNAE rel8 ; Короткий переход, если не выше или равно (CF=1) 8086 73 cb JNB rel8 ; Короткий переход, если не ниже (CF=0) 8086 77 cb JNBE rel8 ; Короткий переход, если не ниже или равно (CF=0 и ZF=0) 8086 73 cb JNC rel8 ; Короткий переход, если не перенос (CF=0) 8086 75 cb JNE rel8 ; Короткий переход, если не равно (ZF=0) 8086 7E cb JNG rel8 ; Короткий переход, если не больше (ZF=1 или SF<>OF) 8086 7C cb JNGE rel8 ; Короткий переход, если не больше или равно (SF<>OF) 8086 7D cb JNL rel8 ; Короткий переход, если не меньше (SF=OF) 8086 7F cb JNLE rel8 ; Короткий переход, если не меньше или равно (ZF=0 и SF=OF) 8086 71 cb JNO rel8 ; Короткий переход, если не переполнение (OF=0) 8086 7B cb JNP rel8 ; Короткий переход, если нечетно (PF=0) 8086 79 cb JNS rel8 ; Короткий переход, если положительно (SF=0) 8086 75 cb JNZ rel8 ; Короткий переход, если не нуль (ZF=0) 8086 70 cb JO rel8 ; Короткий переход, если переполнение (OF=1) 8086 7A cb JP rel8 ; Короткий переход, если паритет (PF=1) 8086 7A cb JPE rel8 ; Короткий переход, если четно (PF=1) 8086 7B cb JPO rel8 ; Короткий переход, если нечетно (PF=0) 8086 78 cb JS rel8 ; Короткий переход, если отрицательно (SF=1) 8086 0F 87 cw/cd JA rel16/32 ; Ближний переход, если выше (CF=0 и ZF=0) Intel386 0F 83 cw/cd JAE rel16/32 ; Ближний переход, если выше или равно (CF=0) Intel386 0F 82 cw/cd JB rel16/32 ; Ближний переход, если ниже (CF=1) Intel386 0F 86 cw/cd JBE rel16/32 ; Ближний переход, если ниже или равно (CF=1 или ZF=1) Intel386 0F 82 cw/cd JC rel16/32 ; Ближний переход, если перенос (CF=1) Intel386 0F 84 cw/cd JE rel16/32 ; Ближний переход, если равно (ZF=1) Intel386 0F 84 cw/cd JZ rel16/32 ; Ближний переход, если нуль (ZF=1) Intel386 0F 8F cw/cd JG rel16/32 ; Ближний переход, если больше (ZF=0 и SF=OF) Intel386 0F 8D cw/cd JGE rel16/32 ; Ближний переход, если больше или равно (SF=OF) Intel386 0F 8C cw/cd JL rel16/32 ; Ближний переход, если меньше (SF<>OF) Intel386 0F 8E cw/cd JLE rel16/32 ; Ближний переход, если меньше или равно (ZF=1 или SF<>OF) Intel386 0F 86 cw/cd JNA rel16/32 ; Ближний переход, если не выше (CF=1 или ZF=1) Intel386 0F 82 cw/cd JNAE rel16/32 ; Ближний переход, если не выше или равно (CF=1) Intel386 0F 83 cw/cd JNB rel16/32 ; Ближний переход, если не ниже (CF=0) Intel386 0F 87 cw/cd JNBE rel16/32 ; Ближний переход, если не ниже или равно (CF=0 и ZF=0) Intel386 0F 83 cw/cd JNC rel16/32 ; Ближний переход, если не перенос (CF=0) Intel386 0F 85 cw/cd JNE rel16/32 ; Ближний переход, если не равно (ZF=0) Intel386 0F 8E cw/cd JNG rel16/32 ; Ближний переход, если не больше (ZF=1 или SF<>OF) Intel386 0F 8C cw/cd JNGE rel16/32 ; Ближний переход, если не больше или равно (SF<>OF) Intel386 0F 8D cw/cd JNL rel16/32 ; Ближний переход, если не меньше (SF=OF) Intel386 0F 8F cw/cd JNLE rel16/32 ; Ближний переход, если не меньше или равно (ZF=0 и SF=OF) Intel386 0F 81 cw/cd JNO rel16/32 ; Ближний переход, если не переполнение (OF=0) Intel386 0F 8B cw/cd JNP rel16/32 ; Ближний переход, если нечетно (PF=0) Intel386 0F 89 cw/cd JNS rel16/32 ; Ближний переход, если положительно (SF=0) Intel386 0F 85 cw/cd JNZ rel16/32 ; Ближний переход, если не нуль (ZF=0) Intel386 0F 80 cw/cd JO rel16/32 ; Ближний переход, если переполнение (OF=1) Intel386 0F 8A cw/cd JP rel16/32 ; Ближний переход, если паритет (PF=1) Intel386 0F 8A cw/cd JPE rel16/32 ; Ближний переход, если четно (PF=1) Intel386 0F 8B cw/cd JPO rel16/32 ; Ближний переход, если нечетно (PF=0) Intel386 0F 88 cw/cd JS rel16/32 ; Ближний переход, если отрицательно (SF=1) Intel386 ==== LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ ==== Processor : 8086+ \\ Flags : no E2 cb LOOP rel8 ; Уменьшить (E)CX и выполнить короткий переход, если (E)CX <> 0 (8086+) E1 cb LOOPE rel8 ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=1 (8086+) E1 cb LOOPZ rel8 ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=1 (8086+) E0 cb LOOPNE rel8 ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=0 (8086+) E0 cb LOOPNZ rel8 ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=0 (8086+) ==== INT ==== Processor : 8086+ \\ Flags : no CC INT 3 ; Вызов прерывания 3 (#BP, точка останова) (8086+) CD ib INT imm8 ; Вызов прерывания imm8 (8086+) CE INTO ; Вызов прерывания 4 (#OF, переполнение), если EFLAGS.OF=1 (8086+) ==== BOUND ==== Processor : 8086+ \\ Flags : no 62 /r BOUND r16,m16&16 ; Проверяет индекс r16 на выход за границы массива m16&16 (80186+) 62 /r BOUND r32,m32&32 ; Проверяет индекс r32 на выход за границы массива m32&32 (80386+) ==== IN ==== Processor : 8086+ \\ Flags : no E4 ib IN AL,imm8 ; Загрузить байт из порта в/в imm8 в регистр AL (8086+) E5 ib IN AX,imm8 ; Загрузить слово из порта в/в imm8 в регистр AL (8086+) E5 ib IN EAX,imm8 ; Загрузить двойное слово из порта в/в imm8 в регистр AL (80386+) EC IN AL,DX ; Загрузить байт из порта в/в DX в регистр AL (8086+) ED IN AX,DX ; Загрузить слово из порта в/в DX в регистр AL (8086+) ED IN EAX,DX ; Загрузить двойное слово из порта в/в DX в регистр AL (80386+) ==== OUT ==== Processor : 8086+ \\ Flags : no E6 ib OUT imm8,AL ; Вывести байт из AL в порт в/в по адресу imm8 (8086+) E7 ib OUT imm8,AX ; Вывести слово из AX в порт в/в по адресу imm8 (8086+) E7 ib OUT imm8,EAX ; Вывести двойное слово из EAX в порт в/в по адресу imm8 (80386+) EE OUT DX,AL ; Вывести байт из AL в порт в/в по адресу в DX (8086+) EF OUT DX,AX ; Вывести слово из AX в порт в/в по адресу в DX (8086+) EF OUT DX,EAX ; Вывести двойное слово из EAX в порт в/в по адресу в DX (80386+) ==== MOVS, MOVSB, MOVSW, MOVSD ==== Processor : 8086+ \\ Flags : no A4 MOVS m8,m8 ; Записать в ячейку по адресу ES:(E)DI байт из ячейки с адресом DS:(E)SI (8086+) A5 MOVS m16,m16 ; Записать в ячейку по адресу ES:(E)DI слово из ячейки с адресом DS:(E)SI (8086+) A5 MOVS m32,m32 ; Записать в ячейку по адресу ES:(E)DI двойное слово из ячейки с адресом DS:(E)SI (80386+) A4 MOVSB ; Записать в ячейку по адресу ES:(E)DI байт из ячейки с адресом DS:(E)SI (8086+) A5 MOVSW ; Записать в ячейку по адресу ES:(E)DI слово из ячейки с адресом DS:(E)SI (8086+) A5 MOVSD ; Записать в ячейку по адресу ES:(E)DI двойное слово из ячейки с адресом DS:(E)SI (80386+) ==== CMPS, CMPSB, CMPSW, CMPSD ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, PF, CF A6 CMPS m8,m8 ; Сравнить байт по адресу DS:(E)SI с байтом по адресу ES:(E)DI (8086+) A7 CMPS m16,m16 ; Сравнить слово по адресу DS:(E)SI со словом по адресу ES:(E)DI (8086+) A7 CMPS m32,m32 ; Сравнить двойное слово по адресу DS:(E)SI с двойным словом по адресу ES:(E)DI (80386+) A6 CMPSB ; Сравнить байт по адресу DS:(E)SI с байтом по адресу ES:(E)DI (8086+) A7 CMPSW ; Сравнить слово по адресу DS:(E)SI со словом по адресу ES:(E)DI (8086+) A7 CMPSD ; Сравнить двойное слово по адресу DS:(E)SI с двойным словом по адресу ES:(E)DI (80386+) ==== SCAS, SCASB, SCASW, SCASD ==== Processor : 8086+ \\ Flags : OF, SF, ZF, AF, PF, CF AE SCAS m8 ; Сравнить байт по адресу ES:(E)DI с AL (8086+) AF SCAS m16 ; Сравнить слово по адресу ES:(E)DI с AX (8086+) AF SCAS m32 ; Сравнить двойное слово по адресу ES:(E)DI с EAX (80386+) AE SCASB ; Сравнить байт по адресу ES:(E)DI с AL (8086+) AF SCASW ; Сравнить байт по адресу ES:(E)DI с AX(8086+) AF SCASD ; Сравнить байт по адресу ES:(E)DI с EAX (80386+) ==== STOS, STOSB, STOSW, STOSD ==== Processor : 8086+ \\ Flags : no AA STOS m8 ; Сохранить AL по адресу ES:(E)DI (8086+) AB STOS m16 ; Сохранить AX по адресу ES:(E)DI (8086+) AB STOS m32 ; Сохранить EAX по адресу ES:(E)DI (80386+) AA STOSB ; Сохранить AL по адресу ES:(E)DI (8086+) AB STOSW ; Сохранить AX по адресу ES:(E)DI (8086+) AB STOSD ; Сохранить EAX по адресу ES:(E)DI (80386+) ==== LODS, LODSB, LODSW, LODSD ==== Processor : 8086+ \\ Flags : no AC LODS m8 ; Считать байт по адресу DS:(E)SI в AL (8086+) AD LODS m16 ; Считать слово по адресу DS:(E)SI в AX (8086+) AD LODS m32 ; Считать двойное слово по адресу DS:(E)SI в EAX (80386+) AC LODSB ; Считать байт по адресу DS:(E)SI в AL (8086+) AD LODSW ; Считать байт по адресу DS:(E)SI в AX (8086+) AD LODSD ; Считать байт по адресу DS:(E)SI в EAX (80386+) ==== INS, INSB, INSW, INSD ==== Processor : 80286+ \\ Flags : no 6C INS m8,DX ; Загрузить байт из порта в/в DX в память по адресу ES:(E)DI (80286+) 6D INS m16,DX ; Загрузить слово из порта в/в DX в память по адресу ES:(E)DI (80286+) 6D INS m32,DX ; Загрузить двойное слово из порта в/в DX в память по адресу ES:(E)DI (80386+) 6C INSB ; Загрузить байт из порта в/в DX в память по адресу ES:(E)DI (80286+) 6D INSW ; Загрузить слово из порта в/в DX в память по адресу ES:(E)DI (80286+) 6D INSD ; Загрузить двойное слово из порта в/в DX в память по адресу ES:(E)DI (80386+) ==== OUTS, OUTSB, OUTSW, OUTSD ==== Processor : 80286+ \\ Flags : no 6E OUTS DX,m8 ; Вывести байт из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+) 6F OUTS DX,m16 ; Вывести слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+) 6F OUTS DX,m32 ; Вывести двойное слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80386+) 6E OUTSB ; Вывести байт из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+) 6F OUTSW ; Вывести слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+) 6F OUTSD ; Вывести двойное слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80386+) ==== REP, REPE, REPNE ==== Processor : 8086+ \\ Flags : no F3 6C REP INS r/m8,DX ; Загрузить (E)CX байт из порта в/в DX в память по адресу ES:(E)DI (80286+) F3 6D REP INS r/m16,DX ; Загрузить (E)CX слов из порта в/в DX в память по адресу ES:(E)DI (80286+) F3 6D REP INS r/m32,DX ; Загрузить (E)CX двойных слов из порта в/в DX в память по адресу ES:(E)DI (80386+) F3 A4 REP MOVS m8,m8 ; Записать по адресу ES:(E)DI блок из (E)CX байт, считываемый по адресу DS:(E)SI (8086+) F3 A5 REP MOVS m16,m16 ; Записать по адресу ES:(E)DI блок из (E)CX слов, считываемый по адресу DS:(E)SI (8086+) F3 A5 REP MOVS m32,m32 ; Записать по адресу ES:(E)DI блок из (E)CX двойных слов, считываемый по адресу DS:(E)SI (80386+) F3 6E REP OUTS DX,r/m8 ; Вывести блок из (E)CX байт из памяти по адресу DS:(E)SI в порт в/в по адресу в DX (80286+) F3 6F REP OUTS DX,r/m16 ; Вывести блок из (E)CX слов из памяти по адресу DS:(E)SI в порт в/в по адресу в DX (80286+) F3 6F REP OUTS DX,r/m32 ; Вывести блок из (E)CX двойных слов из памяти по адресу DS:(E)SI в порт в/в по адрсу в DX (80386+) F3 AC REP LODS AL ; Считать блок из (E)CX байт по адресу DS:(E)SI в AL (8086+) F3 AD REP LODS AX ; Считать блок из (E)CX слов по адресу DS:(E)SI в AX 8086 F3 AD REP LODS EAX ; Считать блок из (E)CX двойных слов по адресу DS:(E)SI в EAX (80386+) F3 AA REP STOS m8 ; Заполнить блок из (E)CX байт по адресу ES:(E)DI содержимым AL (8086+) F3 AB REP STOS m16 ; Заполнить блок из (E)CX слов по адресу ES:(E)DI содержимым AX (8086+) F3 AB REP STOS m32 ; Заполнить блок из (E)CX двойных слов по адресу ES:(E)DI содержимым EAX (80386+) F3 A6 REPE CMPS m8,m8 ; Найти неравные байты в блоках из (E)CX байт по адресам DS:(E)SI и ES:(E)DI (8086+) F3 A7 REPE CMPS m16,m16 ; Найти неравные слова в блоках из (E)CX слов по адресу DS:(E)SI и ES:(E)DI (8086+) F3 A7 REPE CMPS m32,m32 ; Найти неравные двойные слова в блоках из (E)CX двойных слов по адресу DS:(E)SI и ES:(E)DI (80386+) F3 AE REPE SCAS m8 ; Найти байт не равный AL в блоке из (E)CX байт по адресу ES:(E)DI (8086+) F3 AF REPE SCAS m16 ; Найти слово не равное AX в блоке из (E)CX слов по адресу ES:(E)DI (8086+) F3 AF REPE SCAS m32 ; Найти двойное слово не равное EAX в блоке из (E)CX двойных слов по адресу ES:(E)DI (80386+) F2 A6 REPNE CMPS m8,m8 ; Найти равные байты в блоках из (E)CX байт по адресам DS:(E)SI и ES:(E)DI (8086+) F2 A7 REPNE CMPS m16,m16 ; Найти равные слова в блоках из (E)CX слов по адресу DS:(E)SI и ES:(E)DI (8086+) F2 A7 REPNE CMPS m32,m32 ; Найти равные двойные слова в блоках из (E)CX двойных слов по адресу DS:(E)SI и ES:(E)DI (80386+) F2 AE REPNE SCAS m8 ; Найти байт равный AL в блоке из (E)CX байт по адресу ES:(E)DI (8086+) F2 AF REPNE SCAS m16 ; Найти слово равное AX в блоке из (E)CX слов по адресу ES:(E)DI (8086+) F2 AF REPNE SCAS m32 ; Найти двойное слово равное EAX в блоке из (E)CX двойных слов по адресу ES:(E)DI (80386+) ==== STC ==== Processor : 8086+ \\ Flags : CF F9 STC ; Установить EFLAGS.CF = 1 ==== CLC ==== Processor : 8086+ \\ Flags : CF F8 CLC ; Сброс флага EFLAGS.CF ==== CMC ==== Processor : 8086+ \\ Flags : CF F5 CMC ; Инверсия флага EFLAGS.CF ==== STD ==== Processor : 8086+ \\ Flags : DF FD STD ; Установить EFLAGS.DF = 1 ==== CLD ==== Processor : 8086+ \\ Flags : DF FC CLD ; Сброс флага EFLAGS.DF ==== STI ==== Processor : 8086+ \\ Flags : IF FB STI ; Установить флаг разрешения внешних маскируемых прерываний ==== CLI ==== Processor : 8086+ \\ Flags : IF FA CLI ; Сброс флага EFLAGS.IF (внешние маскируемые прерывания запрещены) ==== LAHF ==== Processor : 8086+ \\ Flags : no 9F LAHF ; AH = EFLAGS(SF,ZF,0,AF,0,PF,1,CF)