C. Bombardelli - Desassembler routine in text mode built in assembly language

File: C:\PGM\desa_prg32 COMPLETO.cb

; Código para rotina desassembladora versão 1.03 - 16/03/01 23:13;; (Código Intel #16); Usa: FASM ASSEMBLER, rotinas: print$mem.nsm; Autor: Clovis Bombardelli

;------------------------------------------------------------------------------------------------------------------------------------------------------------]

; INTRODUÇÂO:; Esta é uma rotina construída em linguagem assembly para desassemblar instruções dos processadores INTEL/AMD. Ela deve; ser introduzida como rotina no programa principal.

; RESUMO:; Dado um determinado endereço binário apontado por ebx, o programa escreve numa região da memória indicada por es:edi,; a instrução assembly que representa o código existente no endereço fornecido.

; Espaços de códigos indicados por "livre" posicionam cy=1

; Códigos "vazio" não marcam carry flag. As instruções terão sempre de 2 bytes

; flags de ch; #7 0- end #16 1- end#32; #6 0- op #16 1- op#32; #5 0- dado byte 1- dado word ou dword; #4 0-rm,r 1- r,rm; #3 uso diverso, depende da instrução; #2,1,0 000- sem prefixo,; 001- es:,; 010- cs:,; 011- ss:,; 100- ds:,; 101- fs:,; 110- gs:,; 111- não usado

; Condições que geram erro devem posicionar #0[dh]=1 para na saida posicionar cy=1

; Instrução lock marca #2[dh]=1 para ser utilizado pelas demais instruções para verificar a validade das mesmas.

; Para testar este programa, siga o exemplo abaixo;;teste mov ebx,0x3000; mov edi, 0x3010; mov ch, [modo]; call desa_ini; int3; int 0x20

;

Page: 1


; ROTINA PRINCIPALalign 4desa_ini: push edx and ch, 0xc0 ; só usa os bits #6 e #7 (ver detalhes) mov dh, ch ; salva ambiente em dh

push esi

and [opcode_cont], dword 0 ; inicializa contador and [opcode_cont+4], dword 0 and [opcode_cont+8], dword 0 and [opcode_cont+0xc], dword 0

continue: xor eax, eax ; eax deve ficar zerado aqui mov al, [ebx]

call imp_opcodehex ; imprimir na memoria

inc ebx ; al contém o caratere para impressão. mov cl, al ; se for 00, terminou, mov esi, eax shl esi, 2

reentra: mov esi, [esi + base_indices] ; busca o indice relativo ao 1. codigo

.loop: mov al, [esi] ; loop de impressão inc esi cmp al, 0xff je .a or al, al je .saida call Imp_al ; imprime al (Imp_al) jmp .loop

.a: mov al, [esi] ; busca rotina ff inc esi ;and eax, 0xff ; instrução desnecessária shl eax, 2 call dword [eax + base_rotinas_ff - 0x4] xor eax, eax jmp .loop

.saida: pop esi ; saida geral test dh, 0x01 je .b stc.b: pop edx ret

; Entrada: ds:ebx = posição da leitura; es:edi = posição da escrita; ch = ambiente; para ambiente #32 setar #6,7 =1,; para ambiente #16 setar #6,7=0 (outros bits são desconsiderados); usar outra flag para diferenciar impressao na tela ou na memoria (#5)...reformar

; Saida: cy = 0 ok ebx = posiçao da próxima instrução; edi = posição seguinte à impressão; cy =1 encontrada instrução inválida.

; Altera: ebx, edi, eax, cx

;

Page: 2


; ROTINAS AUXILIARES

align 4opcode_cont dd 0buffer_opcode rb 0xfimp_opcodehex : ; Escreve um byte de opcode em memoria push ebx movzx ebx, byte [opcode_cont] mov byte [buffer_opcode+ebx], al ; exige um buffer em memória para composição inc ebx ; INCREMENTA CONTADOR mov byte [opcode_cont], bl pop ebx ret

align 4imp_dwOpcodehex : push ebx movzx ebx, byte [opcode_cont] mov byte [buffer_opcode+ebx], al inc ebx ror eax, 8 mov byte [buffer_opcode+ebx], al inc ebx ror eax, 8 mov byte [opcode_cont],bl pop ebx ret

align 4imp_ddOpcodehex : push ebx movzx ebx, byte [opcode_cont] mov byte [buffer_opcode+ebx], al inc ebx ror ax, 8 mov byte [buffer_opcode+ebx], al inc ebx ror ax, 8 mov byte [buffer_opcode+ebx], al inc ebx ror ax, 8 mov byte [buffer_opcode+ebx], al inc ebx ror ax, 8 mov byte [opcode_cont],bl pop ebx ret

align 4Imp_al: mov [edi], al inc edi inc edi retn

align 4imp_byhex: ; Imprime um byte em hexadecimal.a: aam 0x10 cmp ah,0x09 jna .b add ah,0x07.b: cmp al,0x09 jna .c add al,0x07.c: add ax,0x3030 xchg ah,al

Page: 3


call Imp_al xchg ah,al call Imp_al retn

align 4imp_wohex: push ecx mov ecx,2 push edx mov edx,eax.c: rol edx,0x08 mov al,dl call imp_byhex loop .c pop edx pop ecx.b: retn

align 4imp_ddhex:.a: push ecx mov ecx,4 push edx mov edx,eax.c: rol edx,0x08 mov al,dl call imp_byhex ; Imprime 1 byte loop .c pop edx pop ecx.b: retn

align 4imp_stringzGS: ; Imprime string tipo Z na posição indicada por es: edi.b: mov al,[esi] or al,al je .a inc esi mov [edi],al inc edi inc edi jmp .b.a: ret

; ROTINAS FF

align 4desa01 : ; marca tamanho do operando add esp, 0x04 ;*** test dh, 0x40 je .a and ch, 0xbf ; 1011 1111, zera #6 jmp continue.a: or ch, 0x40 ; seta #6 jmp continue ; continue: busca novo byte de código ret

align 4desa02 : ; marca tamanho do endereçamento add esp, 0x04 ;*** test dh, 0x80 je .a and ch, 0x7f ; zera #7 jmp continue.a: or ch, 0x80 ; seta #7

Page: 4


jmp continue ; continue: busca novo byte de código ret

align 4desa03 : ; marca prefixo segmento (es, cs, ss, ds) add esp, 0x04 ;*** and ch, 0xf8 test cl, 0x10 jne .a test cl, 0x8 jne .b or ch, 0x1 ; es jmp continue.a: test cl, 0x8 jne .c or ch, 0x3 ; ss jmp continue.b: or ch, 0x2 ; cs jmp continue.c: or ch, 0x4 ; ds jmp continue ; continue: busca novo byte de código ret

align 4desa04 : ; Marca prefixo segmento (fs, gs) add esp, 0x4 ;*** and ch, 0xf8 test cl ,0x1 jne .a or ch, 0x5 ; fs jmp continue.a: or ch, 0x6 ; gs jmp continue ; continue: busca novo byte de código ret

align 4desa05 : ; Opcode de 2 bytes, reentra mov al, [ebx] call imp_opcodehex inc ebx mov cl, al ; al=2o opcode (01,02,08 ou 09) mov esi, eax shl esi, 2 ;1 add esi, 0x400 add esp, 0x4 ;*** jmp reentra ret

align 4desa06 : ; Seleciona e imprime iv ou ib em função de #0[cl] test cl, 0x1 jne desa09 ; Continua em desa08

desa08 : ; Rotina imprime byte hex mov al, [ebx] call imp_opcodehex ; Imprime opcode no buffer em memoria inc ebx call imp_byhex ; Imprime ib hex ret

align 4desa09 : ; Seleciona iv ou iw em função de #6[cl] test ch, 0x40 je desa0a.a: mov eax, [ebx] ; Imprime id call imp_ddOpcodehex add ebx, 0x4

Page: 5


call imp_ddhex ; Imprime id hex ret

align 4desa0a : ; Rotina imprime word hex mov ax, [ebx] call imp_dwOpcodehex add ebx, 0x2 call imp_wohex ; Imprime iw hex

;mov [0xf0], byte 0x61

ret

align 4desa07 : ; Seleciona e imprime ib, iv em função de #5[ch] test ch, 0x20 jne desa09 ; #5[ch]=1, imprime word ou dword jmp desa08 ; #5[ch]=0, imprime byte ret

align 4desa23 : ; Imprime endereço direto em função de #7[ch] test ch,0x80 je desa0a ; Imprime iw jmp desa09 ; Imprime iv (pode ser iw ou id)

align 4desa0b : ; seleciona ab ou av em função de #0[cl] test cl, 0x1 jne desa0f push esi mov esi, reg8.a: call imp_stringzGS ; Imprime rb pop esi ret

align 4desa0f : ; seleciona e imprime ax ou eax push esi mov esi, reg32.b: test ch, 0x40 jne .a inc esi.a: call imp_stringzGS ; Imprime rw ou rd pop esi ret

align 4desa15 : ; Imprime D, em função do prefixo 66 test ch, 0x40 je .a mov al, 'd' call Imp_al.a: ret

align 4desa32 : ; Imprime ib ou cl test ch, 0x8 je desa06 push esi mov esi, reg8+0x3 call imp_stringzGS pop esi ret

align 4desa0e : ; Escolhe e imprime rv em função de #6[ch] e #0,1,2[cl]

Page: 6


mov al, cl.a: push esi mov esi, reg32 and ax, 0x7 ; filtra 8 condições shl al, 0x2 ; al*4 add esi, eax.b: test ch, 0x40 jne .c ; eax inc esi ; ax.c: call imp_stringzGS pop esi ret

align 4desa10 : ; Escolhe e imprime rb em função de #0,1,2[cl] mov al, cl.a: push esi mov esi, reg8 and eax, 0x7.b: mov ah, al shl al, 1 ; al*2+al=al*3 add al, ah xor ah, ah add esi, eax call imp_stringzGS ; Imprime pop esi ret

align 4desa11 : ; Seleciona e imprime condição push esi mov esi, cond mov al, cl and eax, 0x0f ; filtra 16 condições mov ah, al ; pode-se usar jmp desa10.b neste ponto shl al, 1 ; add al, ah xor ah, ah add esi, eax call imp_stringzGS pop esi ret

align 4desa18 : ; Imprime B, W ou D mov al, 'b' test cl, 1 je .a mov al, 'w' test ch, 0x40 je .a mov al, 'd'.a: call Imp_al ret

align 4rmb_rmv : ; Busca byte rm e escolhe rmb / rmv ou rb / rv em função de #0[cl] test cl, 1 je desa13 or ch, 0x20desa13 : ; Busca byte rm e escolhe rmb / rmv ou rb / rv (memória ou registrador) mov al, [ebx] call imp_opcodehex inc ebx mov cl, alrmv : ; Escolhe rmb / rmv ou rb / rv xor al, 0xc0 ; verifica se #6,7 = 11 - end. por registrador

Page: 7


test al, 0xc0 je rvmemv : ; Escolhe memória call desa17 ; Imprime prefixo de segmento, se existir mov al, cl and ax, 0x7 shl ax, 2 test ch, 0x80 je .a add ax, modo32 - modo16.a: push esi mov esi, modo16 add esi, eax call aux_busca pop esi retrv : ; Escolhe rb ou rv (escolhe registrador) test ch, 0x20 jne near desa0e ; Imprime rv jmp desa10 ; Imprime rb

align 4aux_busca : mov esi, [esi] ; busca ponteiro da string.a: mov al, [esi] ; loop de impressão inc esi cmp al, 0xff je .b or al, al je .saida call Imp_al ; Imprime al (Imp_al) jmp .a.b: mov al, [esi] ; busca rotina ff inc esi ;and eax, 0xff shl eax, 2 call dword [eax + base_rotinas_ff - 0x4] xor eax, eax ; GARANTE EAX=0 jmp .a.saida: ret

align 4desa3a : ; Imprime rmb ou rmv dependendo de #5[ch] (usada pelas instruções do grupo 4 e 5) push esi mov al,cl call desa16.b ; rb ou mb pop esi ret

align 4desa16 : ; Imprime rmb ou rmv com prefixo de segmento + by, wo ou dw test cl, 1 je .a.c: or ch, 0x20.a: mov al, [ebx] call imp_opcodehex inc ebx.b: mov cl, al xor al, 0xc0 ; busca rm, inverte #6,7 (qq valor=1 -> busca mem) test al, 0xc0 je rv ; busca r call aux16 ; Imprime by, wo ou dw jmp memv ; busca m

align 4aux16 : push esi

Page: 8


mov esi, tipo test ch, 0x20 ; dado variavel ou byte je .a add esi, 0x3 test ch, 0x40 ; operando #32 je .a add esi, 0x3.a: call imp_stringzGS pop esi ret

align 4desa17 : ; Busca e imprime registrador de segmento como prefixo mov al, ch and eax, 0x7 je .a call aux17 mov al, ':' call Imp_al.a: ret

align 4aux17 : push esi ; Imprime registrador de segmento mov esi, regseg - 0x3 jmp desa10.b

align 4desa19 : ; Altera "si" para buscar uma das quatro instruções: "cbw", "cwde", "cwd" ou "cdq" mov esi, _cbw test cl, 1 jne .a test ch, 0x40 je .saida mov esi, _cwde jmp .saida.a: mov esi, _cwd test ch, 0x40 je .saida mov esi, _cdq.saida: ret ; saida geral

align 4desa1a : ; Imprime endereço relativo curto movsx eax, byte [ebx] call imp_ddOpcodehex inc ebx.a: add eax, ebx test ch, 0x40 je near imp_wohex jmp imp_ddhex

align 4desa1b : ; Imprime endereço relativo longo test ch, 0x80 jne .a movsx eax, word [ebx] call imp_ddOpcodehex add ebx, 0x2 jmp desa1a.a.a: mov eax, [ebx] call imp_ddOpcodehex add ebx, 0x4 jmp desa1a.a

align 4desa1c : ; Imprime es, cs, ss ou ds (OK 30/01/01 15:43) push esi

Page: 9


mov esi, regseg - 0x2 mov al, cl shl al, 1 add al, cl shr al, 0x3 and eax, 0xf add esi, eax call imp_stringzGS pop esi ret

align 4desa1d : ; Imprime fs ou gs push esi mov esi, regseg + 0x0C test cl, 0x8 je .a add esi, 0x3.a: call imp_stringzGS pop esi ret

align 4desa1e : ; Imprime ecx ou cx push esi mov esi, reg32 + 0x4 test ch, 0x40 jne .a inc esi.a: call imp_stringzGS pop esi ret

align 4desa1f : ; Imprime ne ou e em função de #0[cl] push esi mov esi, cond + 0x0f test cl, 1 je .a inc esi.a: call imp_stringzGS pop esi ret

align 4desa20 : ; Escolhe um dos nomes adc, or, add...cmp em função de #3,4,5[cl] mov al, cl ; OK 30/03/01 20:29 test al, 0x2 je .a or ch, 0x10.a: push esi mov esi, grupo1 ; adc, or, add....cmp.b: shr al, 1 and eax, 0x1c add esi, eax call imp_stringzGS pop esi ret

align 4desa21: ; Busca byte rm e imprime "rv,rmv/rmv,rv" ou "rb,rmb/rmb,rb" test ch, 0x10 ; (vale todo intervalo para byte rm) je .a test cl, 1 je .b.c: or ch, 0x20.b: mov al, [ebx]

Page: 10


call imp_opcodehex inc ebx mov cl, al.d: call R_reg ; imprime r'.e: mov al, ',' call Imp_al mov al, cl jmp rmv ; imprime m ou r.a: call rmb_rmv ; Imprime m ou r mov al, ',' call Imp_al ; continua em R_regR_reg: ; Imprime rb ou rv em função de #4,5,6[cl] mov al, cl shr al, 0x3 test ch, 0x20 jne near desa0e.a ; Imprime rv jmp desa10.a ; Imprime rb

align 4desa22 : ; Imprime "mov" setando #5[ch] se #0[cl]=1 e #4[ch] se #1[cl]=1 push esi mov esi, _mov test cl, 0x1 je .a or ch, 0x20.a: test cl, 0x2 je near desa1d.a or ch, 0x10 call imp_stringzGS pop esi ret

align 4desa24: ; Busca byte rm e seleciona um dos nomes do grupo1 em função #3,4,5[byte rm] test cl, 1 je .a or ch, 0x20.a: mov al, [ebx] call imp_opcodehex inc ebx mov cl, al call desa20.a ; busca nome da instrução em função #3,4,5[byte rm].b: mov al, ' ' call Imp_al ; Imprime espaço mov al, cl jmp desa16.b ; busca end à memória em função #1,2,3[byte rm]

align 4desa25: ; Busca byte rm e seleciona um dos nomes do grupo 2.... test cl, 0x1 je .a or ch, 0x20.a: mov al, [ebx] call imp_opcodehex inc ebx mov cl, al call aux25 ; busca nome do grupo 2 em função #3,4,5[byte rm] jmp desa24.b ; repete rotina de endereçamento à memória

align 4aux25 : ; Busca nome das instruções do grupo 2 push esi mov esi, grupo2 jmp desa20.b

align 4desa26 : ; Imprime aviso3 (para ser usada somente internamente à rotina aux_busca (ver grupo3))

Page: 11


push esi ; aux27, mas deve ser indexada por isso recebeu o nome desa26 mov esi, aviso3 call imp_stringzGS add esp, 0x0c pop esi or dh, 0x01 add esp, 0x4 ret

align 4desa27 : ; Busca byte rm e escolhe nome do grupo 3... test cl, 1 je .a or ch, 0x20.a: mov al, [ebx] call imp_opcodehex inc ebx mov cl, al push esi mov esi, grupo3 shr al, 0x3 and eax, 0x7 je .b ; instrução test m,i mov ah, al ; rotina para as demais instruções (NOT...NEG...) shl al, 0x2 ; x4 add al, ah ; x5 and eax, 0x3f ; filtra add esi, eax ; ajusta ponteiro call aux_busca.a ; se a rotina 0xff26 for encontrada, imprime aviso3 e sai pop esi mov al, ' ' call Imp_al ; Imprime espaço mov al, cl jmp desa16.b.b: ; test rmv,iv call aux_busca.a ; rotina específica para test rmv,iv mov al, ' ' call Imp_al ; Imprime espaço mov al, cl call desa16.b ; busca rmv mov al, ',' call Imp_al ; Imprime ',' pop esi jmp desa07

align 4desa28 : ; Busca endereço far imediato test ch, 0x40 je .a push dword [ebx] add ebx, 0x4 call desa0a mov al, ':' call Imp_al pop eax call imp_ddhex retn.a: push word [ebx] add ebx, 0x2 call desa0a mov al, ':' call Imp_al pop eax call imp_wohex ret

align 4

Page: 12


desa29 : ; Busca deslocamento nos modos de endereçamento test cl, 0xc0 je .a test cl, 0x80 jne .b mov dl, [ebx] inc ebx test dl, 0x80 je .c mov al, '-' neg dl jmp .d.c: mov al, '+'.d: call Imp_al mov al, dl call imp_opcodehex call imp_byhex retn.b: test ch, 0x80 jne .e mov ax, [ebx] call imp_dwOpcodehex add ebx, 0x2 test ah, 0x80 je .f neg eax push eax mov al, '-' jmp .g.f: push eax mov al, '+'.g: call Imp_al pop eax call imp_wohex retn.e: mov eax, [ebx] call imp_ddOpcodehex ; Imprime opcode add ebx, 0x4 bt eax, 0x1f jae .h neg eax push eax mov al, '-' jmp .i.h: push eax mov al, '+'.i: call Imp_al pop eax call imp_ddhex.a: ret

align 4desa2a: ; Executa rotina 21 com #5[ch]=1. or ch, 0x10 ; Referencia incondicional à memoria tipo rv,rmv jmp desa21.c

align 4desa2b : ; Busca byte rm e busca endereçamento à memoria (rv,m). or ch, 0x20 ; marca para rv, para usar a rotina 21 mov al, [ebx] ; Referencia a registrador imprime instrução inválida call imp_opcodehex inc ebx mov cl, al xor al, 0xc0 test al, 0xc0 jne near desa21.d push esi ; instrução inválida se referenciar um registrador

Page: 13


mov esi, aviso5 call imp_stringzGS pop esi or dh, 0x01 ; marcação de erro para acionar cy=1 na saida ret

align 4desa2c: ; Executa rotina 21 com #6[ch]=0. usada pela instrução "arpl" and ch, 0xbf jmp desa21.a

align 4desa2d : ; Busca byte rm especifica para referencia a registradores de segmento (rseg,mem ou mem,rseg) or ch, 0x20 and ch, 0xbf ; fixa registradores sempre do tipo word test cl, 2 je .a mov al, [ebx] ; ordem rseg, mem call imp_opcodehex inc ebx mov cl, al or ch, 0x8 ; fixa o modo de uso da rotina aux2d call aux2d jmp desa21.e.a: call desa13 ; ordem mem, rseg mov al, ',' call Imp_alaux2d: push esi mov esi, regseg mov al, cl and eax, 0x38 test ch, 0x8 je .a cmp al, 0x8 je .b.a: mov ah, al shl al, 1 add al, ah shr al, 3 cmp al, 0xf ja .b xor ah, ah add esi, eax jmp .c.b: mov esi, aviso2 or dh, 0x1 ; posiciona erro.c: call imp_stringzGS pop esi ret

align 4desa2e : ; Rotina especifica para prefixos "rep", "repe" e "repne" mov al,[ebx] call imp_opcodehex inc ebx push eax xor al, 0xa6 test al, 0xa6 jne .a ; pula se for "rep" call desa1f ; Imprime "e" ou "ne".a: mov al, ' ' call Imp_al pop eax mov cl, al mov esi, eax

Page: 14


shl esi, 2 ; 1 mudado para 2--- OK add esp, 0x4 jmp reentra

; antiga rotina 2f; sem_uso mov al, [ebx]; call imp_opcodehex; inc ebx; mov cl, al; mov si, ax; shl si, 1; jmp aux_busca

align 4desa30 : ; Rotina especifica para as instruções movsx e movzx test cl, 1 je .a or ch, 0x20.a: mov al, [ebx] call imp_opcodehex inc ebx mov cl, al test ch, 0x20 je .b or ch, 0x40 call R_reg and ch, 0xbf.c: mov al, ',' call Imp_al mov al, cl jmp desa16.b.b: ;or ch, 0x01 call R_reg and ch, 0x9f jmp .c ret

align 4desa31 : ; Busca byte rm para endereçamento tipo rmv,rv. marca #3[ch]=1 se #0[byte anterior]=1 test cl, 1 je .a or ch, 0x08.a: call desa16.c ; busca byte rm e imprime m ou r mov al, ',' call Imp_al jmp R_reg ; Imprime r'

align 4desa33 : ; Escolhe e imprime uma das letras: "s", "r" ou "c" mov al, cl sub al, 0xa3 je .a shr al, 0x1 push esi mov esi, src - 0x2 add esi, eax call imp_stringzGS pop esi.a: ret

align 4desa34 : ; Escolhe e imprime uma das letras: "s", "r" ou "c", específica para grupo 8 mov al, [ebx] call imp_opcodehex inc ebx mov cl, al and eax, 0x38

Page: 15


shr al, 1 or ch, 0x8 cmp al, 0x8 je .a push esi jb .b mov esi, src - 0xa add esi, eax.c: call imp_stringzGS pop esi.a: retn.b: mov al, 'x' ; instrução inválida se fora do intervalo válido call Imp_al ; #3,4,5[byte rm] < 4 mov esi, aviso5 or dh, 0x01 jmp .c

align 4desa35 : ; Escolhe uma das funções do grupo 0f00 ("ldtr", "str"....etc), em função de #3,4,5[byte rm] push esi mov esi, grupo6.a: mov al, [ebx] ; busca byte rm call imp_opcodehex inc ebx mov cl, al and eax, 0x38 xor ah, ah shr al, 1 ; desloca 8 por 1(/2) para calcular o endereço dentro do blocogrupo6 add esi, eax call aux_busca.a pop esi ret

align 4desa36 : ; Busca endereçamento rmw em função de #0,1,2[cl] and ch, 0xbf ; zera #6, seta #5 or ch, 0x20 ; fixa variavel em word mov al, cl jmp desa16.b ; busca modo de endereçamento

align 4desa37 : ; Busca endereçamento m em função de #0,1,2[cl]. mov al, cl ; O tamanho do operando depende da instrução xor al, 0xc0 test al, 0xc0 je desa38 ; mostra aviso de instrução inválida se o endereço referenciarregistrador jmp rmv ; busca modo de endereçamento

align 4desa38 : ; Imprime "Instrução inválida" push esi mov esi, aviso1 call imp_stringzGS pop esi or dh, 0x01 ; posiciona marca para erro ret

align 4desa39 : ; Escolhe uma das funções do grupo 0f01, em função de #3,4,5 [byte rm] push esi mov esi, grupo7 jmp desa35.a

align 4desa3b : ; Busca byte rm e escolhe uma das instruções do grupo 5

Page: 16


or ch, 0x20 mov esi, grupo5 mov al, [ebx] call imp_opcodehex inc ebx mov cl, al jmp aux4d

align 4desa3c : ; Imprime rmv (usada pela instrução push rmv do grupo 5) or ch, 0x20 jmp desa16.b

align 4desa44 : ; Busca proximo byte e imprime "mov" posicionando #6[ch]=1, mov al, [ebx] ; (usada nas instruções tipo mov cr0, rd) call imp_opcodehex inc ebx mov cl, al or ch, 0x40 ; continua na rotina 3d

desa3d : ; Imprime 'mov' push esi mov esi, _mov call imp_stringzGS pop esi ret

align 4desa3e : ; Imprime 'pop' push esi mov esi, _pop call imp_stringzGS pop esi ret

align 4desa3f : ; Imprime 'push' push esi mov esi, _push call imp_stringzGS pop esi ret

align 4desa0c : ; Diferencia [endereçamento direto] de [bp+deslocamento] test cl, 0xc0 je .a ; se #6,7[cl]=0 buscar .a ou .b (end dir) push esi mov esi,0xabcd mov esi, insbp call aux_busca.a pop esi retn.a: ; Busca endereçcamento direto word test ch, 0x80 jne .b mov ax, [ebx] ; pode-se substituir por jmp desa0a call imp_dwOpcodehex add ebx, 0x2 call imp_wohex retn.b: ; Busca endereçcamento direto dword mov eax, [ebx] ; pode-se substituir por desa09.a call imp_ddOpcodehex ; Imprime opcode add ebx, 0x4 call imp_ddhex

Page: 17


ret

align 4desa0d : ; Diferencia [endereçamento direto] de [ebp+deslocamento] test cl, 0xc0 je desa0c.a push esi mov esi, insebp call aux_busca.a pop esi ret

align 4desa40 : ; Busca byte rm para instruções mpu (rotina principal) push esi mov al, cl and eax, 0x7 mov dl, al mov al, [ebx] call imp_opcodehex inc ebx mov cl, al xor al, 0xc0 test al, 0xc0 je .a mov esi, R_d8 ; base do bloco com referencia à memória and eax, 0x38 shr al, 1 add esi, eax mov al, dl shl al, 4 add esi, eax call aux_busca mov al, cl call memv pop esi retn.a: mov esi, R_d8.c0 ; base do bloco com referencia aos registradores shl ax, 2 ; add esi, eax mov al, dl shl ax, 7 add esi, eax xor eax, eax call aux_busca pop esi ret

align 4desa41 : ; Imprime "st0,stx" em função de #0,1,2[cl] push esi mov esi, _st call imp_stringzGS mov al, ',' call Imp_al mov al, cl and eax, 0x7 shl al, 0x2 mov esi, _st add esi,eax call imp_stringzGS pop esi ret

align 4desa42 : ; Imprime "stx,st0" em função de #0,1,2[cl] push esi

Page: 18


mov esi, _st mov al, cl and eax, 0x7 shl al, 0x2 add esi,eax call imp_stringzGS mov al, ',' call Imp_al mov esi, _st call imp_stringzGS pop esi ret

align 4desa43 : ; Imprime stx em função de #0,1,2[cl] mov al, cl and eax, 0x7 push esi mov esi, _st shl al, 0x2 add esi, eax call imp_stringzGS pop esiR_ret: ret

align 4desa45 : ;.Marca erro posicionando #1[dh]=1 or dh, 0x1 ret

align 4desa46 : ; Marca #2[dh]=1 e continua. Rotina especifica para instrução lock or dh, 0x2 add esp, 0x4 jmp continue

align 4desa47 : ; Busca byte rm para instruções dos grupos 12, 13 e 14 mov al, cl and eax, 3 je .a dec al shl al, 0x4 mov esi, grupo12 add esi, eax mov al, [ebx] call imp_opcodehex inc ebx mov cl, al xor al, 0xc0 test al, 0xc0 jne near desa38 ; referencia à memoria deve buscar outro ponteiro and eax, 0x38 ; ou indicar inst. inválida shr al, 0x2 ; add si, ax ; só altera si para busca do ponteiro mov esi, [esi] ; busca novo ponteiro ret.a: mov esi, livre ret

align 4desa2f : ; Imprime #3,4,5[byte rm] como um numero entre 0 e 7 mov al, cl and eax, 0x38 shr al, 0x3 add al, 0x30 call Imp_al

Page: 19


ret

; sem_uso2 ; Imprime D, em função do pref. 67 ( semelhante à desa15, mas sensivel ao bit #7[ch]; test ch, 0x80; je .a; mov al, 'd'; call Imp_al;.a ret

align 4desa14 : ; Busca byte sib mov dl, [ebx] inc ebx mov al, dl push esi mov esi, reg32 and ax, 0x7 shl al, 0x2 add esi, eax call imp_stringzGS mov al, '+' call Imp_al mov al, dl call imp_opcodehex ;* shr al, 0x3 mov esi, reg32 and eax, 0x7 shl al, 0x2 add esi, eax call imp_stringzGS pop esi push ecx mov cl, dl shr cl , 6 je .a mov al , '*' call Imp_al mov al, 1 shl al, cl add al, 0x30 call Imp_al.a: pop ecx jmp desa29

align 4desa12 : ; Escolhe e imprime rd em função de #0,1,2[cl] push esi mov esi, reg32 and ax, 0x7 shl al, 0x2 add esi, eax call imp_stringzGS pop esi ret

align 4desa48 : ; Busca byte rm e escolhe umas das instruções do grupo 4 mov esi, grupo4 mov al, [ebx] call imp_opcodehex inc ebx mov cl, al jmp aux4d

align 4desa49 : ; Busca byte rm para instruções mmx (rmmx, rmmx/m64) mov al, [ebx]

Page: 20


call imp_opcodehex inc ebx mov cl, al shr al, 3 call rmmx mov al, ',' call Imp_al mov al, claux4a: xor al,0xc0 test al,0xc0 je near memv ; Escolhe memóriarmmx: push esi ; Imprime rmmx, se não for memória mov esi, _xmm + 1 and eax, 0x7 shl eax, 2 add esi, eax call imp_stringzGS pop esi ret

align 4desa4a : ; Busca byte rm para instruções mmx reversas (rmmx/m64, rmmx) mov al, [ebx] call imp_opcodehex inc ebx mov cl, al call aux4a mov al, ',' call Imp_al mov al, cl shr al, 3 jmp rmmx

align 4desa4b : ; Busca byte rm para instrução movd (rmmx,r/m32) mov al, [ebx] call imp_opcodehex inc ebx mov cl, al shr al, 3 call rmmx mov al, ',' call Imp_al mov al, cl or ch, 0x60 ; seta rd jmp rmv

align 4desa4c : ; Busca byte rm para instrução movdr (r/m32,rmmx) mov al, [ebx] call imp_opcodehex inc ebx mov cl, al or ch, 0x60 call rmv mov al, ',' call Imp_al mov al, cl shr al, 3 jmp rmmx

align 4desa4d : ; Busca ponteiro para instruções do grupo 12 mov esi, grupo12aux4d: and eax, 0x38 shr al, 1

Page: 21


add esi, eax call aux_busca ret

align 4desa4e : ; Busca ponteiro para instruções do grupo 13 mov esi, grupo13 jmp aux4d

align 4desa4f : ; Busca ponteiro para instruções do grupo 14 mov esi, grupo14 jmp aux4d

align 4desa50 : ; Rotina usada pelas instruções dos blocos 12, 13 e 14 mov al,cl ; byte rm deve já estar em cl. call rmmx ; Imprime reg mmx, ref. à memória devem buscar... mov al, ',' call Imp_al mov al, [ebx] ; busca dado imediato call imp_opcodehex inc ebx call imp_byhex ; Imprime ib ret

; DADOS CONSTANTES

; db 'desa1.3 jan01'; Tabela de ponteiros das rotinas FFalign 4base_rotinas_ff:dd desa01 ; Marca prefixo de tamanho de operandodd desa02 ; Marca prefixo de tamanho de endereçodd desa03 ; Marca prefixo de segmento es, cs, ss ou dsdd desa04 ; Marca prefixo de segmento fs ou gsdd desa05 ; Marca instrução com dois bytes, busca opcode na tabela seguintedd desa06 ; Escolhe e imprime ib ou iv em função de #0[cl]dd desa07 ; Seleciona e imprime ib, iv em função de #5[ch]dd desa08 ; Imprime ibdd desa09 ; Escolhe e imprime iw ou id em função de #6[ch]dd desa0a ; Imprime iwdd desa0b ; Escolhe e imprime al ou axv em função de #0[cl]dd desa0c ; Diferencia [endereçamento direto] de [bp+deslocamento]dd desa0d ; Diferencia [endereçamento direto] de [ebp+deslocamento]dd desa0e ; Escolhe e imprime rv em função de #6[ch] e #0,1,2[cl]dd desa0f ; Escolhe e imprime ax ou eaxdd desa10 ; Escolhe e imprime rb em função de #0,1,2[cl]dd desa11 ; Escolhe e imprime condiçãodd desa12 ; Imprime rd em função de #0,1,2[cl] (similar a desa0e, insensível ao pref. 66)dd desa13 ; Busca byte rm e escolhe rmb / rmv ou rb / rv (memória ou registrador)dd desa14 ; Busca byte sibdd desa15 ; Imprime D, em função do prefixo 66dd desa16 ; Imprime rmb ou rmv com prefixo de segmento + by, wo ou dddd desa17 ; Imprime prefixo de segmento em função #0,1,2[ch]dd desa18 ; Imprime b, w ou ddd desa19 ; Altera "si" para buscar uma das quatro : "cbw", "cwde", "cwd" ou "cdq"dd desa1a ; Imprime endereço relativo curtodd desa1b ; Imprime endereço relativo longo variáveldd desa1c ; Imprime es, cs, ss ou dsdd desa1d ; Imprime fs ou gsdd desa1e ; Imprime cx ou ecxdd desa1f ; Imprime ne ou edd desa20 ; Imprime add, or, adc, sbb, and, sub, xor, cmp em função #3,4,5[cl]dd desa21 ; Escolhe rv,rmv/rmv,rv ou rb,rmb/rmb,rbdd desa22 ; Imprime 'mov' setando #5[ch] se #0[cl]=1

Page: 22


dd desa23 ; Imprime endereço direto em função #7[ch]dd desa24 ; Busca byte rm e seleciona um dos nomes do grupo1 em função #3,4,5[byte rm]dd desa25 ; Seleciona e imprime um dos nomes..rol, ror, rcl, rcr, shl, shr, sal, sardd desa26 ; Imprime aviso3: código de instrução não usado (usada pela rotina desa27)dd desa27 ; Escolhe nome test, x, not, neg, mul, imul,...dd desa28 ; Busca endereço far imediatodd desa29 ; Busca deslocamento nos modos de endereçamentodd desa2a ; Executa rotina 21 com #5[ch]=1. Referencia à memoria tipo rv,rmv incondicionaldd desa2b ; Busca byte rm e busca endereçamento à memoria (rv,m)dd desa2c ; Executa rotina 21 com #6[ch]=0. Usada pela instrução "arpl"dd desa2d ; Busca byte rm especifica para referencia a reg seg (rseg,rm ou rm,rseg)dd desa2e ; Rotina especifica para prefixos "rep", "repe" e "repne"dd desa2f ; Imprime #3,4,5[byte rm] como um numero entre 0 e 7dd desa30 ; Rotina especifica para as instruções movsx e movzxdd desa31 ; Busca byte rm para end tipo rmv,rv. marca #3[ch]=1 se #0[byte anterior]=1dd desa32 ; Imprime ib ou cl em função de #3[cl]dd desa33 ; Escolhe e imprime uma das letras: "s", "r" ou "c"dd desa34 ; Escolhe e imprime uma das letras: "s", "r" ou "c", específica para grupo 8dd desa35 ; Escolhe no grupo 0f00 ("ldtr", "str"....etc), em função de #3,4,5[byte rm]dd desa36 ; Busca endereçamento rmw em função de #0,1,2[cl]dd desa37 ; Busca end M em função de #0,1,2[cl]. O tam. do operando depende da instruçãodd desa38 ; Imprime "Instrução inválida"dd desa39 ; Escolhe uma das funções do grupo 0f01, em função de #3,4,5 [byte rm]dd desa3a ; Imprime rmb ou rmv dependendo de #5[ch] (usada pelas instr do grupo 4 e 5)dd desa3b ; Busca byte rm e escolhe uma das instruções do grupo 5dd desa3c ; Imprime rmv (usada pela instrução push rmv do grupo 5)dd desa3d ; Imprime 'mov'dd desa3e ; Imprime 'pop'dd desa3f ; Imprime 'push'dd desa40 ; Busca byte rm para instruções mpu (rotina principal)dd desa41 ; Imprime "st0,stx" em função de #0,1,2[cl]dd desa42 ; Imprime "stx,st0" em função de #0,1,2[cl]dd desa43 ; Imprime stx em função de #0,1,2[cl]dd desa44 ; Busca proximo byte e imprime "mov" posicionando #6[ch]=1dd desa45 ; Marca erro posicionando #1[dh]=1dd desa46 ; Marca #2[dh]=1 e continua. Rotina especifica para instrução lockdd desa47 ; Busca byte rm para instruções dos grupos 12, 13 e 14dd desa48 ; Busca byte rm e escolhe umas das instruções do grupo 4dd desa49 ; Busca byte rm para instruções mmx (rmmx, rmmx/m64)dd desa4a ; Busca byte rm para instruções mmx reversas (rmmx/m64, rmmx)dd desa4b ; Busca byte rm para instrução movd (rmmx,r/m32)dd desa4c ; Busca byte rm para instrução movdr (r/m32,rmmx)dd desa4d ; Busca ponteiro para instruções do grupo 12dd desa4e ; Busca ponteiro para instruções do grupo 13dd desa4f ; Busca ponteiro para instruções do grupo 14dd desa50 ; Rotina usada pelas instruções dos blocos 12, 13 e 14

modo16: dd m16.0 dd m16.1 dd m16.2 dd m16.3 dd m16.4 dd m16.5 dd m16.6 dd m16.7

modo32: dd m32.0 dd m32.1 dd m32.2 dd m32.3 dd m32.4 dd m32.5 dd m32.6 dd m32.7

Page: 23


grupo4 dd _incx dd _decx dd livre dd livre dd livre dd livre dd livregrupo4.7 dd livre

grupo5 dd _incx dd _decx dd _callx dd _callfarx dd _jmpx dd _jmpfarx dd _pusxgrupo5.7 dd livre

; IMPORTANTE: Os blocos 12, 13 e 14 devem ficar coesos entre si; Prever mais 3 blocos livres para as referencias à memória nestes 3 blocos. (ou pensar noutra solução)grupo12: dd livre dd livre dd _psrlwi dd livre dd _psrawi dd livre dd _psllwi dd livre

grupo13 dd livre dd livre dd _psrldi dd livre dd _psradi dd livre dd _pslldi dd livre

grupo14 dd livre dd livre dd _psrlqi dd livre dd livre dd livre dd _psllqi dd livre

; times 0x180 - ( _ - __ ) db 0;-----------------------------------------------------------------------------------------------------------------------------------------------------------

; Tabela de índices (aviso4= instrução indisponível)db 'BASE INDICE'align 16base_indices:dd _add ; 00- add rmb,rbdd _add ; 01- add rmv,rvdd _add ; 02- add rb,rmbdd _add ; 03- add rv,rmvdd _addi ; 04- add al,ib ; a mesma rotina serve para os códigos 04 e 05dd _addi ; 05- add axv,ivdd _pushs ; 06- push esdd _pops ; 07- pop esdd _add ; 08- or rmb,rbdd _add ; 09- or rmv,rvdd _add ; 0a- or rb,rmbdd _add ; 0b- or rv,rmvdd _addi ; 0c- or al,ib

Page: 24


dd _addi ; 0d- or axv,ivdd _pushs ; 0e- push csdd _of ; 0f- opcode 2 bytes

dd _add ; 10- adc rmb,rbdd _add ; 11- adc rmv,rvdd _add ; 12- adc rb,rmbdd _add ; 13- adc rv,rmvdd _addi ; 14- adc al,ibdd _addi ; 15- adc axv,ivdd _pushs ; 16- push ssdd _pops ; 17- pop ssdd _add ; 18- sbb rmb,rbdd _add ; 19- sbb rmv,rvdd _add ; 1a- sbb rb,rmbdd _add ; 1b- sbb rv,rmvdd _addi ; 1c- sbb al,ibdd _addi ; 1d- sbb axv,ivdd _pushs ; 1e- push dsdd _pops ; 1f- pop ds

dd _add ; 20- and rmb,rbdd _add ; 21- and rmv,rvdd _add ; 22- and rb,rmbdd _add ; 23- and rv,rmvdd _addi ; 24- and al,ibdd _addi ; 25- and axv,ivdd _rseg0 ; 26- prefixo esdd _daa ; 27- daa OK 30/01/01 9:57dd _add ; 28- sub rb,rmbdd _add ; 29- sub rv,rmvdd _add ; 2a- sub rmb,rbdd _add ; 2b- sub rmv,rvdd _addi ; 2c- sub al,ibdd _addi ; 2d- sub axv, ivdd _rseg0 ; 2e- prefixo csdd _das ; 2f- das OK 30/01/01 9:57

dd _add ; 30- xor rmb,rbdd _add ; 31- xor rmv,rvdd _add ; 32- xor rb,rmbdd _add ; 33- xor rv,rmvdd _addi ; 34- xor al,ibdd _addi ; 35- xor axv,ivdd _rseg0 ; 36- prefixo ssdd _aaa ; 37- aaa OK 22/01/01 3:12dd _add ; 38- cmp rmb,rbdd _add ; 39- cmp rmv,rvdd _add ; 3a- cmp rb,rmbdd _add ; 3b- cmp rv,rmvdd _addi ; 3c- cmp al,1bdd _addi ; 3d- cmp axv,ivdd _rseg0 ; 3e- prefixo dsdd _aas ; 3f- aas OK 22/01/01 3:12

dd _inc ; 40- inc axv OKdd _inc ; 41- inc cxv OKdd _inc ; 42- inc dxvdd _inc ; 43- inc bxvdd _inc ; 44- inc spvdd _inc ; 45- inc bpvdd _inc ; 46- inc sivdd _inc ; 47- inc divdd _dec ; 48- dec axv OKdd _dec ; 49- dec cxvdd _dec ; 4a- dec dxvdd _dec ; 4b- dec bxv

Page: 25


dd _dec ; 4c- dec spvdd _dec ; 4d- dec bpvdd _dec ; 4e- dec sivdd _dec ; 4f- dec div

dd _pushr ; 50- push axvdd _pushr ; 51- push cxvdd _pushr ; 52- push dxvdd _pushr ; 53- push bxvdd _pushr ; 54- push spvdd _pushr ; 55- push bpvdd _pushr ; 56- push sivdd _pushr ; 57- push divdd _popr ; 58- pop axvdd _popr ; 59- pop cxvdd _popr ; 5a- pop dxvdd _popr ; 5b- pop bxvdd _popr ; 5c- pop spvdd _popr ; 5d- pop bpvdd _popr ; 5e- pop sivdd _popr ; 5f- pop div

dd _pusha ; 60- pushavdd _popa ; 61- popavdd _bound ; 62- bound rv,m2vdd _arpl ; 63- afpl mw,rwdd _rseg1 ; 64- prefixo fsdd _rseg1 ; 65- prefixo gsdd _o32 ; 66- prefixo de tamanho de operandodd _a32 ; 67- prefixo de tamanho de endereçamentodd _pushiv ; 68- push ivdd _imulv ; 69- imul rv,rmv,ivdd _pushib ; 6a- push ibdd _imulb ; 6b- imul rv,rmv,ibdd _ins ; 6c- insbdd _ins ; 6d- insvdd _outs ; 6e- outsbdd _outs ; 6f- outsv

dd _jcc ; 70- jo short OK 23/01/01 15:05 (usa prefixo 66 para a32)dd _jcc ; 71- jno shortdd _jcc ; 72- jb short OK 23/01/01 15:05dd _jcc ; 73- jae shortdd _jcc ; 74- je shortdd _jcc ; 75- jne shortdd _jcc ; 76- jbe shortdd _jcc ; 77- ja shortdd _jcc ; 78- js shortdd _jcc ; 79- jns shortdd _jcc ; 7a- jpe shortdd _jcc ; 7b- jpo shortdd _jcc ; 7c- jl shortdd _jcc ; 7d- jge shortdd _jcc ; 7e- jle shortdd _jcc ; 7f- jg short

dd _imebb ; 80- grupo 1 - imediato rmb,ibdd _imebb ; 81- grupo 1 - imediato rmb,ivdd _imebb ; 82- grupo 1 - não usadodd _imebv ; 83- grupo 1 - imediato rmv,ibdd _testr ; 84- test rmb,rbdd _testr ; 85- test rmv,rvdd _xchgr ; 86- xchg rmb,rbdd _xchgr ; 87- xchg rmv,rvdd _movmr ; 88- mov rmb,rbdd _movmr ; 89- mov rmv,rvdd _movmr ; 8a- mov rmb,ib

Page: 26


dd _movmr ; 8b- mov rmv,ivdd _movsm ; 8c- mov rmw, segrdd _lea ; 8d- lea rv,mdd _movsm ; 8e- mov segr,mwdd _poprm ; 8f- pop rmv

dd _nop ; 90- xchg eav,eav/nop OK 22/01/01 3:10dd _xchg ; 91- xchg eav,ecvdd _xchg ; 92- xchg eav,edvdd _xchg ; 93- xchg eav,ebvdd _xchg ; 94- xchg eav,spvdd _xchg ; 95- xchg eav,bpvdd _xchg ; 96- xchg eav,sivdd _xchg ; 97- xchg eav,divdd _cbwm ; 98- cbw/cwdedd _cbwm ; 99- cwd/cdqdd _calli ; 9a- call far diretadd _fwait ; 9b- fwait OK 22/01/01 3:32dd _pushf ; 9c- pushfvdd _popf ; 9d- popfvdd _sahf ; 9e- sahf OK 22/01/01 3:31dd _lahf ; 9f- lahf OK 22/01/01 3:32

dd _movi ; a0- mov al,xbdd _movi ; a1- mov axv,xvdd _mova ; a2- mov xb,aldd _mova ; a3- mov xv,axvdd _movs ; a4- movsbdd _movs ; a5- movsvdd _cmps ; a6- cmpsbdd _cmps ; a7- cmpsvdd _testi ; a8- test al,ibdd _testi ; a9- test axv,ivdd _stos ; aa- stosbdd _stos ; ab- stosvdd _lods ; ac- lodsbdd _lods ; ad- lodsvdd _scas ; ae- scasbdd _scas ; af- scasv

dd _movrb ; b0- mov al,ibdd _movrb ; b1- mov cl,ibdd _movrb ; b2- mov dl,ibdd _movrb ; b3- mov bl,1bdd _movrb ; b4- mov ah,ibdd _movrb ; b5- mov ch,ibdd _movrb ; b6- mov dh,ibdd _movrb ; b7- mov bh,ibdd _movrv ; b8- mov axv,ivdd _movrv ; b9- mov cxv,ivdd _movrv ; ba- mov dxv,ivdd _movrv ; bb- mov bxv,ivdd _movrv ; bc- mov spv,ivdd _movrv ; bd- mov bpv,ivdd _movrv ; be- mov siv,ivdd _movrv ; bf- mov div,iv

dd _deslib ; c0- grupo 2 - desloc rmb,ibdd _deslib ; c1- grupo 2 - desloc rmv,ibdd _retiw ; c2- ret iw OK 23/01/01 10:10dd _ret ; c3- ret (near) OK 22/01/01 3:33dd _les ; c4- les rv,mpdd _lds ; c5- lds rv,mpdd _movmi ; c6- grupo 11 - mov rmb,ibdd _movmi ; c7- grupo 11 - mov rmv,ivdd _enter ; c8- enter iw,ibdd _leave ; c9- leave OK 23/01/01 10:10

Page: 27


dd _retfiw ; ca- retf iwdd _retf ; cb- retfdd _int3 ; cc- int3 OK 23/01/01 10:09dd _intib ; cd- int ib OK 23/01/01 10:09dd _into ; ce- into OK 23/01/01 10:10dd _iret ; cf- iretv

dd _desl1 ; d0- grupo 2 - desloc rmb,1dd _desl1 ; d1- grupo 2 - desloc rmv,1dd _deslcl ; d2- grupo 2 - desloc rmb,cldd _deslcl ; d3- grupo 2 - desloc rmv,cldd _aam ; d4- aam (ib)dd _aad ; d5- aad (ib)dd _salc ; d6- set al from carry flag, não documentadadd _xlatb ; d7- xlatbdd mpu ; d8- instrução mpudd mpu ; d9- instrução mpudd mpu ; da- instrução mpudd mpu ; db- instrução mpudd mpu ; dc- instrução mpudd mpu ; dd- instrução mpudd mpu ; de- instrução mpudd mpu ; df- instrução mpu

dd _loopc ; e0- loopne shortdd _loopc ; e1- loope shortdd _loop ; e2- loop shortdd _jcxz ; e3- jcxv shortdd _in ; e4- in al,ibdd _in ; e5- in axv,ibdd _out ; e6- out al,ibdd _out ; e7- out axv,ibdd _call ; e8- call neardd _jmp ; e9- jmp neardd _jmpf ; ea- jmp fardd _jmps ; eb- jmp shortdd _indx ; ec- in al,dxdd _indx ; ed- in axv,dxdd _outdx ; ee- out al,dxdd _outdx ; ef- out axv,dx

dd _lock ; f0- prefixo lockdd _int1 ; f1- int1 (P6)dd _rep ; f2- prefixo repnedd _rep ; f3- prefixo repe/repdd _hlt ; f4- hltdd _cmc ; f5- cmcdd _una ; f6- grupo 3 - unário mbdd _una ; f7- grupo 3 - unário mvdd _clc ; f8- clcdd _stc ; f9- stcdd _cli ; fa- clidd _sti ; fb- stidd _cld ; fc- clddd _std ; fd- stddd _indfe ; fe- grupo 4 - inc/dec rmbdd _indff ; ff- grupo 5 - indireto

; tabela do segundo bytedd _i0f00 ; 0f 00- grupo 6 - instruções 0f 00dd _i0f01 ; 0f 01- grupo 7 - instruções 0f 01dd _lar ; 0f 02- lar rv,rmvdd _lsl ; 0f 03- lsl rv, rmvdd livre ; 0f 04- *dd _load286 ; 0f 05- loadall286 (286, não doc)dd _clts ; 0f 06- cltsdd _loadall ; 0f 07- loadall (386, não doc)

Page: 28


dd _invd ; 0f 08- invd (486)dd _wbinvd ; 0f 09- wbinvd (486)dd livre ; 0f 0a- *dd aviso4 ; 0f 0b-dd aviso4 ; 0f 0c-dd aviso4 ; 0f 0d-dd aviso4 ; 0f 0e-dd aviso4 ; 0f 0f-

dd _umov ; 0f 10- umov rmb,rb (386, não doc)dd _umov ; 0f 11- umov rmv,rv (386, não doc)dd _umov ; 0f 12- umov rb,rmb (386, não doc)dd _umov ; 0f 13- umov rv,rmv (386, não doc)dd aviso4 ; 0f 14-dd aviso4 ; 0f 15-dd aviso4 ; 0f 16-dd aviso4 ; 0f 17-dd aviso4 ; 0f 18- grupo 16 -dd livre ; 0f 19- *dd livre ; 0f 1a- *dd livre ; 0f 1b- *dd livre ; 0f 1c- *dd livre ; 0f 1d- *dd livre ; 0f 1e- *dd livre ; 0f 1f- *

dd _crr ; 0f 20- mov rd,crndd _drr ; 0f 21- mov rd,drndd _cr ; 0f 22- mov crn,rddd _dr ; 0f 23- mov drn,rddd _trr ; 0f 24- mov rd,trndd livre ; 0f 25- *dd _tr ; 0f 26- mov trn,rddd livre ; 0f 27- *dd aviso4 ; 0f 28-dd aviso4 ; 0f 29-dd aviso4 ; 0f 2a-dd aviso4 ; 0f 2b-dd aviso4 ; 0f 2c-dd aviso4 ; 0f 2d-dd aviso4 ; 0f 2e-dd aviso4 ; 0f 2f-

dd _wrmsr ; 0f 30- wrmsr (p5)dd _rdtsc ; 0f 31- rdtsc (p5)dd _rdmsr ; 0f 32- rdmsr (p5)dd _rdpmc ; 0f 33- rdpmc (p6)dd aviso4 ; 0f 34-dd aviso4 ; 0f 35-dd livre ; 0f 36- *dd livre ; 0f 37- *dd livre ; 0f 38- *dd livre ; 0f 39- *dd livre ; 0f 3a- *dd livre ; 0f 3b- *dd livre ; 0f 3c- *dd livre ; 0f 3d- *dd livre ; 0f 3e- *dd livre ; 0f 3f- *

dd _cmov ; 0f 40- cmovo rv,rmv (p6)dd _cmov ; 0f 41- cmovno rv,rmv (p6)dd _cmov ; 0f 42- cmovb rv,rmv (p6)dd _cmov ; 0f 43- cmovae rv,rmv (p6)dd _cmov ; 0f 44- cmove rv,rmv (p6)dd _cmov ; 0f 45- cmovne rv,rmv (p6)dd _cmov ; 0f 46- cmovbe rv,rmv (p6)

Page: 29


dd _cmov ; 0f 47- cmova rv,rmv (p6)dd _cmov ; 0f 48- cmovs rv,rmv (p6)dd _cmov ; 0f 49- cmovns rv,rmv (p6)dd _cmov ; 0f 4a- cmovpe rv,rmv (p6)dd _cmov ; 0f 4b- cmovpo rv,rmv (p6)dd _cmov ; 0f 4c- cmovl rv,rmv (p6)dd _cmov ; 0f 4d- cmovge rv,rmv (p6)dd _cmov ; 0f 4e- cmovle rv,rmv (p6)dd _cmov ; 0f 4f- cmovg rv,rmv (p6)

dd aviso4 ; 0f 50- paveb mmxreg,r/m64 (mmx cyryx somente)dd aviso4 ; 0f 51- paddsiw mmxreg,r/m64 (mmx cyrix somente)dd aviso4 ; 0f 52- pmagw mmxreg,r/m64 (mmx cyrix somente)dd aviso4 ; 0f 53-dd aviso4 ; 0f 54- pdistib mmxreg,mem64 (mmx cyrix somente)dd aviso4 ; 0f 55- psubsiw mmxreg,r/m64 (mmx cyrix somente)dd aviso4 ; 0f 56-dd aviso4 ; 0f 57-dd aviso4 ; 0f 58- pmvzb mmxreg,mem64 (mmx cyrix somente)dd aviso4 ; 0f 59- pmulhrw mmxreg,r/m64 (mmx cyrix somente)dd aviso4 ; 0f 5a- pmvnzb mmxreg,mem64 (mmx cyrix somente)dd aviso4 ; 0f 5b- pmvlzb mmxreg,mem64 (mmx cyrix somente)dd aviso4 ; 0f 5c- pmvgezb mmxreg,mem64 (mmx cyrix somente)dd aviso4 ; 0f 5d- pmulhriw mmxreg,r/m64(mmx cyrix somente)dd aviso4 ; 0f 5e- pmachriw mmxreg,mem64(mmx cyrix somente)dd aviso4 ; 0f 5f-

dd _punpcklbw ; 0f 60- punpcklbw mmxreg,r/m64 (p5, mmx)dd _punpcklwd ; 0f 61- punpcklwd mmxreg,r/m64 (p5, mmx)dd _punpckldq ; 0f 62- punpckldq mmxreg,r/m64 (p5, mmx)dd _packsswb ; 0f 63- packsswb mmxreg,r/m64 (p5, mmx)dd _pcmpgtb ; 0f 64- pcmpgtb mmxreg,r/m64 (p5, mmx)dd _pcmpgtw ; 0f 65- pcmpgtw mmxreg,r/m64 (p5, mmx)dd _pcmpgtd ; 0f 66- pcmpgtd mmxreg,r/m64 (p5, mmx)dd _packuswb ; 0f 67- packuswb mmxreg,r/m64 (p5, mmx)dd _punpckhbw ; 0f 68- punpckhbw mmxreg,r/m64 (p5, mmx)dd _punpckhwd ; 0f 69- punpckhwd mmxreg,r/m64 (p5, mmx)dd _punpckhdq ; 0f 6a- punpckhdq mmxreg,r/m64 (p5, mmx)dd _packssdd ; 0f 6b- packssdd mmxreg,r/m64 (p5, mmx)dd livre ; 0f 6c- *dd livre ; 0f 6d- *dd _movd ; 0f 6e- movd mmxreg,r/m32 (p5, mmx)dd _movq ; 0f 6f- movq mmxreg,r/m64 (p5, mmx)

dd aviso4 ; 0f 70-dd _gr121314 ; 0f 71- grupo 12 -dd _gr121314 ; 0f 72- grupo 13 -dd _gr121314 ; 0f 73- grupo 14 - instruções de shiftdd _pcmpeqb ; 0f 74- pcmpeqb mmxreg,r/m64 (p5, mmx)dd _pcmpeqw ; 0f 75- pcmpeqw mmxreg,r/m64 (p5, mmx)dd _pcmpeqd ; 0f 76- pcmpeqd mmxreg,r/m64 (p5, mmx)dd _emms ; 0f 77- emms (p5, mmx)dd aviso4 ; 0f 78-dd aviso4 ; 0f 79-dd aviso4 ; 0f 7a-dd aviso4 ; 0f 7b-dd aviso4 ; 0f 7c-dd aviso4 ; 0f 7d-dd _movdr ; 0f 7e- movd r/m32,mmxreg (p5, mmx)dd _movqr ; 0f 7f- movq r/m64,mmxreg (p5, mmx)

dd _jccnear ; 0f 80- jo neardd _jccnear ; 0f 81- jno neardd _jccnear ; 0f 82- jb neardd _jccnear ; 0f 83- jae neardd _jccnear ; 0f 84- je neardd _jccnear ; 0f 85- jne near

Page: 30


dd _jccnear ; 0f 86- jbe neardd _jccnear ; 0f 87- ja neardd _jccnear ; 0f 88- js neardd _jccnear ; 0f 89- jns neardd _jccnear ; 0f 8a- jpe neardd _jccnear ; 0f 8b- jpo neardd _jccnear ; 0f 8c- jl neardd _jccnear ; 0f 8d- jge neardd _jccnear ; 0f 8e- jle neardd _jccnear ; 0f 8f- jg near

dd _set ; 0f 90- seto rmbdd _set ; 0f 91- setno rmbdd _set ; 0f 92- setb rmbdd _set ; 0f 93- setae rmbdd _set ; 0f 94- sete rmbdd _set ; 0f 95- setne rmbdd _set ; 0f 96- setbe rmbdd _set ; 0f 97- seta rmbdd _set ; 0f 98- sets rmbdd _set ; 0f 99- setns rmbdd _set ; 0f 9a- setpe rmbdd _set ; 0f 9b- setpo rmbdd _set ; 0f 9c- setl rmbdd _set ; 0f 9d- setge rmbdd _set ; 0f 9e- setle rmbdd _set ; 0f 9f- setg rmb

dd _pushfs ; 0f a0- push fsdd _popfs ; 0f a1- pop fsdd _cpuid ; 0f a2- cpuid (p5)dd _bt ; 0f a3- bt rm, rvdd _shld ; 0f a4- shld rmv,rv, ibdd _shld ; 0f a5- shld rmv,rv, cldd _cmpxchg486 ; 0f a6- cmpxchg486 rmb,rb (486, não doc)dd _cmpxchg486 ; 0f a7- cmpxchg486 rmv,rv (486, não doc)dd _pushfs ; 0f a8- push gsdd _popfs ; 0f a9- pop gsdd _rsm ; 0f aa- rsm (p5)dd _bt ; 0f ab- bts rm, rvdd _shrd ; 0f ac- shrd rmv,rv,ibdd _shrd ; 0f ad- shrd rmv,rv,cldd aviso4 ; 0f ae- grupo 15 -dd _imul ; 0f af- imul rv,rmv

dd _cmpxchg ; 0f b0- cmpxchg rmb,rb (p5)dd _cmpxchg ; 0f b1- cmpxchg rmv,rv (p5)dd _lss ; 0f b2- lss rv,mpdd _bt ; 0f b3- btr rm, rvdd _lfs ; 0f b4- lfs rv,mpdd _lgs ; 0f b5- lgs rv,mpdd _movzx ; 0f b6- movzx rv,rmbdd _movzx ; 0f b7- movzx rd,rmwdd aviso4 ; 0f b8-dd aviso4 ; 0f b9-dd _bti ; 0f ba- grupo 8 - bloco de instruções btx rv/m,ibdd _bt ; 0f bb- btc rm,rvdd _bsf ; 0f bc- bsf rv,rmvdd _bsr ; 0f bd- bsr rv,rmvdd _movsx ; 0f be- movsx rv,rmbdd _movsx ; 0f bd- movsx rd,rmw

dd _xadd ; 0f c0- xadd rmb,rb (486)dd _xadd ; 0f c1- xadd rmv,rv (486)dd aviso4 ; 0f c2-dd livre ; 0f c3- *dd aviso4 ; 0f c4-

Page: 31


dd aviso4 ; 0f c5-dd aviso4 ; 0f c6-dd aviso4 ; 0f c7- grupo 9 - cmpxchgg8b mem (p5)dd _bswap ; 0f c8- bswap eax (486)dd _bswap ; 0f c9- bswap ecx (486)dd _bswap ; 0f ca- bswap edx (486)dd _bswap ; 0f cb- bswap ebx (486)dd _bswap ; 0f cc- bswap esp (486)dd _bswap ; 0f cd- bswap ebp (486)dd _bswap ; 0f ce- bswap esi (486)dd _bswap ; 0f cf- bswap edi (486)

dd livre ; 0f d0- *dd _psrlw ; 0f d1- psrlw mmxreg,r/m64 (p5, mmx)dd _psrld ; 0f d2- psrld mmxreg,r/m64 (p5, mmx)dd _psrlq ; 0f d3- psrlq mmxreg,r/m64 (p5, mmx)dd livre ; 0f d4- *dd _pmullw ; 0f d5- pmullw mmxreg,r/m64 (p5, mmx)dd livre ; 0f d6- *dd aviso4 ; 0f d7-dd _psubusb ; 0f d8- psubusb mmxreg,r/m64 (p5, mmx)dd _psubusw ; 0f d9- psubusw mmxreg,r/m64 (p5, mmx)dd aviso4 ; 0f da-dd _pand ; 0f db- pand mmxreg,r/m64 (p5, mmx)dd _paddusb ; 0f dc- paddusb mmxreg,r/m64 (p5, mmx)dd _paddusw ; 0f dd- paddusw mmxreg,r/m64 (p5, mmx)dd aviso4 ; 0f de-dd _pandn ; 0f df- pandn mmxreg,r/m64 (p5, mmx)

dd aviso4 ; 0f e0-dd _psraw ; 0f e1- psraw mmxreg,r/m64 (p5, mmx)dd _psrad ; 0f e2- psrad mmxreg,r/m64 (p5, mmx)dd aviso4 ; 0f e3-dd aviso4 ; 0f e4-dd _pmulhw ; 0f e5- pmulhw mmxreg,r/m64 (p5, mmx)dd livre ; 0f e6- *dd aviso4 ; 0f e7-dd _psubsb ; 0f e8- psubsb mmxreg,r/m64 (p5, mmx)dd _psubsw ; 0f e9- psubsw mmxreg,r/m64 (p5, mmx)dd aviso4 ; 0f ea-dd _por ; 0f eb- por mmxreg,r/m64 (p5, mmx)dd _paddsb ; 0f ec- paddsb mmxreg,r/m64 (p5, mmx)dd _paddsw ; 0f ed- paddsw mmxreg,r/m64 (p5, mmx)dd aviso4 ; 0f ee-dd _pxor ; 0f ef- pxor mmxreg,r/m64 (p5, mmx)

dd livre ; 0f f0- *dd _psllw ; 0f f1- psllw mmxreg,r/m64 (p5, mmx)dd _pslld ; 0f f2- pslld mmxreg,r/m64 (p5, mmx)dd _psllq ; 0f f3- psllq mmxreg,r/m64 (p5, mmx)dd livre ; 0f f4- *dd _pmadddd ; 0f f5- pmadddd mmxreg,r/m64 (p5, mmx)dd aviso4 ; 0f f6-dd aviso4 ; 0f f7-dd _psubb ; 0f f8- psubb mmxreg,r/m64 (p5, mmx)dd _psubw ; 0f f9- psubw mmxreg,r/m64 (p5, mmx)dd _psubd ; 0f fa- psubd mmxreg,r/m64 (p5, mmx)dd livre ; 0f fb- *dd _paddb ; 0f bc- paddb mmxreg,r/m64 (p5, mmx)dd _paddd ; 0f fd- paddd mmxreg,r/m64 (p5, mmx)dd _paddd ; 0f fe- paddd mmxreg,r/m64 (p5, mmx)dd livre ; 0f ff- *

; * = código de instrução não usado

; tabela A (pfu) para byte rm entre 00 e bf (reservado 128 bytes, 80h)R_d8 dd _fadd_single_real

Page: 32


dd _fmul_single_real dd _fcom_single_real dd _fcomp_single_real dd _fsub_single_real dd _fsubr_single_real dd _fdiv_single_real dd _fdivr_single_real

R_d9 dd _fld_single_real dd vazio dd _fst_single_real dd _fstp_single_real dd _fldenv dd _fldcw_2bytes dd _fstenv dd _fstcw_2bytes

R_da dd _fiadd_dd_Int dd _fimul_dd_Int dd _ficom_dd_Int dd _ficomp_dd_Int dd fisub_dd_Int dd fisubr_dd_Int dd fidiv_dd_Int dd fidivr_dd_Int

R_db dd fild_dd_Int dd vazio dd fist_dd_Int dd fistp_dd_Int dd vazio dd fld_ext_real dd vazio dd fstp_ext_real

R_dc dd _fadd_doble_real dd _fmul_doble_real dd _fcom_doble_real dd _fcomp_doble_real dd _fsub_doble_real dd _fsubr_doble_real dd _fdiv_doble_real dd _fdivr_doble_real

R_dd dd _fld_doble_real dd vazio dd _fst_doble_real dd _fstp_doble_real dd _frstor dd vazio dd _fsave dd _fstsw

R_de dd _fiadd_wo_Int dd _fimul_wo_Int dd _ficom_wo_Int dd _ficomp_wo_Int dd _fisub_wo_Int dd _fisubr_wo_Int dd _fidiv_wo_Int dd _fidivr_wo_Int

R_df dd _fild_wo_Int dd vazio dd _fist_wo_Int dd _fistp_wo_Int dd _fbld_pack_bcd

Page: 33


dd _fild_qw_Int dd _fbstp_pack_bcd dd _fistp_qw_Int

; tabela B (fpu) para byte rm entre c0 e ff (reservado 512 bytes, 400h)R_d8.c0 dd _fadd_sti dd _fadd_sti dd _fadd_sti dd _fadd_sti dd _fadd_sti dd _fadd_sti dd _fadd_sti dd _fadd_sti

R_d8.c8 dd _fmul_sti dd _fmul_sti dd _fmul_sti dd _fmul_sti dd _fmul_sti dd _fmul_sti dd _fmul_sti dd _fmul_sti

R_d8.d0 dd _fcom_sti dd _fcom_sti dd _fcom_sti dd _fcom_sti dd _fcom_sti dd _fcom_sti dd _fcom_sti dd _fcom_sti

R_d8.d8 dd _fcomp_sti dd _fcomp_sti dd _fcomp_sti dd _fcomp_sti dd _fcomp_sti dd _fcomp_sti dd _fcomp_sti dd _fcomp_sti

R_d8.e0 dd _fsub_sti dd _fsub_sti dd _fsub_sti dd _fsub_sti dd _fsub_sti dd _fsub_sti dd _fsub_sti dd _fsub_sti

R_d8.e8 dd _fsubr_sti dd _fsubr_sti dd _fsubr_sti dd _fsubr_sti dd _fsubr_sti dd _fsubr_sti dd _fsubr_sti dd _fsubr_sti

R_d8.f0 dd _fdiv_sti dd _fdiv_sti dd _fdiv_sti dd _fdiv_sti dd _fdiv_sti dd _fdiv_sti dd _fdiv_sti dd _fdiv_sti

Page: 34


R_d8.f8 dd _fdivr_sti dd _fdivr_sti dd _fdivr_sti dd _fdivr_sti dd _fdivr_sti dd _fdivr_sti dd _fdivr_sti dd _fdivr_sti

_d9.c0 dd _fld_sti dd _fld_sti dd _fld_sti dd _fld_sti dd _fld_sti dd _fld_sti dd _fld_sti dd _fld_sti

_d9.c8 dd _fxch_sti dd _fxch_sti dd _fxch_sti dd _fxch_sti dd _fxch_sti dd _fxch_sti dd _fxch_sti dd _fxch_sti

_d9.d0 dd _fnop dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_d9.d8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_d9.e0 dd _fchs dd _fabs dd vazio dd vazio dd _ftst dd _fxam dd vazio dd vazio

_d9.e8 dd _fld1 dd _fldl2t dd _fldl2e dd _fldpi dd _fldlg2 dd _fldln2 dd _fldz dd vazio

_d9.f0 dd _f2xm1 dd _fyl2x dd _fptan

Page: 35


dd _fpatan dd _fxtract dd _fprem1 dd _fdecstp dd _fincstp

_d9.f8 dd _fprem dd _fyl2xp1 dd _fsqrt dd _fsincos dd _frndint dd _scale dd _fsin dd _fcos

_da.c0 dd _fcmovb_sti dd _fcmovb_sti dd _fcmovb_sti dd _fcmovb_sti dd _fcmovb_sti dd _fcmovb_sti dd _fcmovb_sti dd _fcmovb_sti

_da.c8 dd _fcmove_sti dd _fcmove_sti dd _fcmove_sti dd _fcmove_sti dd _fcmove_sti dd _fcmove_sti dd _fcmove_sti dd _fcmove_sti

_da.d0 dd _fcmovbe_sti dd _fcmovbe_sti dd _fcmovbe_sti dd _fcmovbe_sti dd _fcmovbe_sti dd _fcmovbe_sti dd _fcmovbe_sti dd _fcmovbe_sti

_da.d8 dd _fcmovu_sti dd _fcmovu_sti dd _fcmovu_sti dd _fcmovu_sti dd _fcmovu_sti dd _fcmovu_sti dd _fcmovu_sti dd _fcmovu_sti

_da.e0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_da.e8 dd _fucompp dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

Page: 36


dd vazio

_da.f0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_da.f8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_db.c0 dd _fcmovnb_sti dd _fcmovnb_sti dd _fcmovnb_sti dd _fcmovnb_sti dd _fcmovnb_sti dd _fcmovnb_sti dd _fcmovnb_sti dd _fcmovnb_sti

_db.c8 dd _fcmovne_sti dd _fcmovne_sti dd _fcmovne_sti dd _fcmovne_sti dd _fcmovne_sti dd _fcmovne_sti dd _fcmovne_sti dd _fcmovne_sti

_db.d0 dd _fcmovnbe_sti dd _fcmovnbe_sti dd _fcmovnbe_sti dd _fcmovnbe_sti dd _fcmovnbe_sti dd _fcmovnbe_sti dd _fcmovnbe_sti dd _fcmovnbe_sti

_db.d8 dd _fcmovnu_sti dd _fcmovnu_sti dd _fcmovnu_sti dd _fcmovnu_sti dd _fcmovnu_sti dd _fcmovnu_sti dd _fcmovnu_sti dd _fcmovnu_sti

_db.e0 dd vazio dd vazio dd _fclex dd _finit dd vazio dd vazio dd vazio dd vazio

_db.e8 dd _fucomi_sti dd _fucomi_sti

Page: 37


dd _fucomi_sti dd _fucomi_sti dd _fucomi_sti dd _fucomi_sti dd _fucomi_sti dd _fucomi_sti

_db.f0 dd _fcomi_sti dd _fcomi_sti dd _fcomi_sti dd _fcomi_sti dd _fcomi_sti dd _fcomi_sti dd _fcomi_sti dd _fcomi_sti

_db.f8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_dc.c0 dd _fadd_st0 dd _fadd_st0 dd _fadd_st0 dd _fadd_st0 dd _fadd_st0 dd _fadd_st0 dd _fadd_st0 dd _fadd_st0

_dc.c8 dd _fmul_st0 dd _fmul_st0 dd _fmul_st0 dd _fmul_st0 dd _fmul_st0 dd _fmul_st0 dd _fmul_st0 dd _fmul_st0

_dc.d0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_dc.d8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_dc.e0 dd _fsubr_st0 dd _fsubr_st0 dd _fsubr_st0 dd _fsubr_st0 dd _fsubr_st0 dd _fsubr_st0

Page: 38


dd _fsubr_st0 dd _fsubr_st0

_dc.e8 dd _fsub_st0 dd _fsub_st0 dd _fsub_st0 dd _fsub_st0 dd _fsub_st0 dd _fsub_st0 dd _fsub_st0 dd _fsub_st0

_dc.f0 dd _fdivr_st0 dd _fdivr_st0 dd _fdivr_st0 dd _fdivr_st0 dd _fdivr_st0 dd _fdivr_st0 dd _fdivr_st0 dd _fdivr_st0

_dc.f8 dd _fdiv_st0 dd _fdiv_st0 dd _fdiv_st0 dd _fdiv_st0 dd _fdiv_st0 dd _fdiv_st0 dd _fdiv_st0 dd _fdiv_st0

_dd.c0 dd _ffree_sti dd _ffree_sti dd _ffree_sti dd _ffree_sti dd _ffree_sti dd _ffree_sti dd _ffree_sti dd _ffree_sti

_dd.c8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_dd.d0 dd _fst_sti dd _fst_sti dd _fst_sti dd _fst_sti dd _fst_sti dd _fst_sti dd _fst_sti dd _fst_sti

_dd.d8 dd _fstp_sti dd _fstp_sti dd _fstp_sti dd _fstp_sti dd _fstp_sti dd _fstp_sti dd _fstp_sti dd _fstp_sti

_dd.e0 dd _fucom_st0

Page: 39


dd _fucom_st0 dd _fucom_st0 dd _fucom_st0 dd _fucom_st0 dd _fucom_st0 dd _fucom_st0 dd _fucom_st0

_dd.e8 dd _fucomp_sti dd _fucomp_sti dd _fucomp_sti dd _fucomp_sti dd _fucomp_sti dd _fucomp_sti dd _fucomp_sti dd _fucomp_sti

_dd.f0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_dd.f8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_de.c0 dd _faddp_st0 dd _faddp_st0 dd _faddp_st0 dd _faddp_st0 dd _faddp_st0 dd _faddp_st0 dd _faddp_st0 dd _faddp_st0

_de.c8 dd _fmulp_st0 dd _fmulp_st0 dd _fmulp_st0 dd _fmulp_st0 dd _fmulp_st0 dd _fmulp_st0 dd _fmulp_st0 dd _fmulp_st0

_de.d0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_de.d8 dd _fcompp dd vazio dd vazio dd vazio dd vazio

Page: 40


dd vazio dd vazio dd vazio

_de.e0 dd _fsubrp_st0 dd _fsubrp_st0 dd _fsubrp_st0 dd _fsubrp_st0 dd _fsubrp_st0 dd _fsubrp_st0 dd _fsubrp_st0 dd _fsubrp_st0

_de.e8 dd _fsubp_st0 dd _fsubp_st0 dd _fsubp_st0 dd _fsubp_st0 dd _fsubp_st0 dd _fsubp_st0 dd _fsubp_st0 dd _fsubp_st0

_de.f0 dd _fdivrp_st0 dd _fdivrp_st0 dd _fdivrp_st0 dd _fdivrp_st0 dd _fdivrp_st0 dd _fdivrp_st0 dd _fdivrp_st0 dd _fdivrp_st0

_de.f8 dd _fdivp_st0 dd _fdivp_st0 dd _fdivp_st0 dd _fdivp_st0 dd _fdivp_st0 dd _fdivp_st0 dd _fdivp_st0 dd _fdivp_st0

_df.c0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_df.c8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_df.d0 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

Page: 41


_df.d8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_df.e0 dd _fstsw_ax dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

_df.e8 dd _fucomip_sti dd _fucomip_sti dd _fucomip_sti dd _fucomip_sti dd _fucomip_sti dd _fucomip_sti dd _fucomip_sti dd _fucomip_sti

_df.f0 dd _fcomip_sti dd _fcomip_sti dd _fcomip_sti dd _fcomip_sti dd _fcomip_sti dd _fcomip_sti dd _fcomip_sti dd _fcomip_sti

_df.f8 dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio dd vazio

; times 0x580+0x480 - ( _ - __ ) db 0

; tabela de stringsb_pref db 0x26,0x2e,0x36,0x3e,0x64,0x65,0x66,0x67,0xf0,0xf1 ; 0 final nao é necessarioreg8 db 'al',0,'cl',0,'dl',0,'bl',0,'ah',0,'ch',0,'dh',0,'bh',0reg32 db 'eax',0,'ecx',0,'edx',0,'ebx',0,'esp',0,'ebp',0,'esi',0,'edi',0regseg db 'es',0,'cs',0,'ss',0,'ds',0,'fs',0,'gs',0cond db 'o',0,0,'no',0,'b',0,0,'ae',0,'e',0,0,'ne',0,'be',0,'a',0,0,'s',0,0,'ns',0,'pe',0,'po',0,'l',0,0,'ge',0,'le',0,'g',0tipo db 'by ',0,'wo ',0,'dd ',0grupo1 db 'add',0,'or',0,0,'adc',0,'sbb',0,'and',0,'sub',0,'xor',0,'cmp',0grupo2 db 'rol',0,'ror',0,'rcl',0,'rcr',0,'shl',0,'shr',0,'sal',0,'sar',0grupo3 db 'test',0,0xff,0x26,'@@',0,'not',0,0,'neg',0,0,'mul',0,0,'imul',0,'div',0,0,'idiv',0aviso1 db 'instrução inválida',0aviso2 db 'registrador de segmento inválido',0aviso3 db 'codigo de instrução não usado',0; (para instr não implementadas neste programa)aviso4 db 'código de instrução indisponivel',0aviso5 db 'inválida. (gera Int 06 ao ser executada)'livre db 'esc',0xff,0x45,0src db 's',0,'r',0,'c',0_xmm db 'xmm0',0,'xmm1',0,'xmm2',0,'mm3',0,'xmm4',0,'xmm5',0,'xmm6',0,'xmm7',0_st db 'st0',0,'st1',0,'st2',0,'st3',0,'st4',0,'st5',0,'st6',0,'st7',0

Page: 42


m16.0 db '[bx+si',0xff,0x29,']',0m16.1 db '[bx+di',0xff,0x29,']',0m16.2 db '[bp+si',0xff,0x29,']',0m16.3 db '[bp+di',0xff,0x29,']',0m16.4 db '[si',0xff,0x29,']',0m16.5 db '[di',0xff,0x29,']',0m16.6 db '[',0xff,0x0c,']',0m16.7 db '[bx',0xff,0x29,']',0

insbp db 'bp',0xff,0x29,0

m32.0 db '[eax',0xff,0x29,']',0m32.1 db '[ecx',0xff,0x29,']',0m32.2 db '[edx',0xff,0x29,']',0m32.3 db '[ebx',0xff,0x29,']',0m32.4 db '[',0xff,0x14,']',0m32.5 db '[',0xff,0x0d,']',0m32.6 db '[esi',0xff,0x29,']',0m32.7 db '[edi',0xff,0x29,']',0

insebp db 'ebp',0xff,0x29,0 ; especial para a instruçcao ebp

; instruções 386 ou abaixo_aaa db 'aaa',0_aas db 'aas',0_hlt db 'hlt',0_cli db 'cli',0_std db 'std',0_clc db 'clc',0_nop db 'nop',0_sti db 'sti',0_mov db 'mov',0_leave db 'leave',0_ret db 'ret',0_retf db 'retf',0_fwait db 'fwait',0_sahf db 'sahf',0_lahf db 'lahf',0_cmc db 'cmc',0_int3 db 'int3',0_into db 'into',0_stc db 'stc',0_cld db 'cld',0_cbw db 'cbw',0_cwde db 'cwde',0_cwd db 'cwd',0_cdq db 'cdq',0_das db 'das',0_daa db 'daa',0_push db 'push',0_pop db 'pop',0_salc db 'salc',0

_retiw db 'ret ',0xff,0x0a,0_retfiw db 'retf ',0xff,0x0a,0_intib db 'int ',0xff,0x08,0_enter db 'enter ',0xff,0x0a,',',0xff,0x08,0_xlatb db 0xff,0x17,'xlatb',0_iret db 'iret',0xff,0x15,0_inc db 'inc ',0xff,0x0e,0_dec db 'dec ',0xff,0x0e,0_add db 0xff,0x20,' ',0xff,0x21,0 ; usada tambem paraor,adc,sbb,and,sub,xor,cmp_addi db 0xff,0x20,' ',0xff,0x0b,',',0xff,0x06,0_imebb db 0xff,0x24,',',0xff,0x07,0_imebv db 0xff,0x24,',',0xff,0x08,0

Page: 43


_pushs db 0xff,0x3f,' ',0xff,0x1c,0_pops db 0xff,0x3e,' ',0xff,0x1c,0_pushr db 0xff,0x3f,' ',0xff,0x0e,0_popr db 0xff,0x3e,' ',0xff,0x0e,0_pusha db 0xff,0x3f,'a',0xff,0x15,0_popa db 0xff,0x3e,'a',0xff,0x15,0_pushf db 0xff,0x3f,'f',0xff,0x15,0_popf db 0xff,0x3e,'f',0xff,0x15,0_pushib db 0xff,0x3f,' ',0xff,0x08,0_pushiv db 0xff,0x3f,' ',0xff,0x09,0_poprm db 0xff,0x3e,' ',0xff,0x16,0_aam db 'aam (',0xff,0x08,')',0_aad db 'aad (',0xff,0x08,')',0_stos db 'stos',0xff,0x18,0_scas db 'scas',0xff,0x18,0_ins db 'ins',0xff,0x18,0_outs db 0xff,0x17,'outs',0xff,0x18,0_lods db 0xff,0x17,'lods',0xff,0x18,0_cmps db 0xff,0x17,'cmps',0xff,0x18,0_movs db 0xff,0x17,'movs',0xff,0x18,0_in db 'in ',0xff,0x0b,',#',0xff,0x08,0_out db 'out #',0xff,0x08,',',0xff,0x0b,0_indx db 'in ',0xff,0x0b,',[dx]',0_outdx db 'out [dx],',0xff,0x0b,0_testi db 'test ',0xff,0x0b,',',0xff,0x06,0_testr db 'test ',0xff,0x21,0_xchg db 'xchg ',0xff,0x0f,',',0xff,0x0e,0_xchgr db 'xchg ',0xff,0x21,0_call db 'call ',0xff,0x1b,0_calli db 'call ',0xff,0x28,0_jcxz db 'j',0xff,0x1e,'z ', 0xff,0x1a,0_jcc db 'j',0xff,0x11,' ',0xff,0x1a,0_jmps db 'jmp ',0xff,0x1a,0_jmp db 'jmp ',0xff,0x1b,0_jmpf db 'jmp ',0xff,0x1b,0_jmpi db 'jmp ',0xff,0x28,0_loop db 'loop',0xff,0x15,' ',0xff,0x1a,0_loopc db 'loop',0xff,0x1f,0xff,0x15,' ',0xff,0x1a,0_les db 'les ',0xff,0x2b,0_lds db 'lds ',0xff,0x2b,0_lea db 'lea ',0xff,0x2b,0_bound db 'bound ',0xff,0x2b,0_arpl db 'arpl ',0xff,0x2c,0_deslib db 0xff,0x25,',',0xff,0x08,0_deslcl db 0xff,0x25,',cl',0_desl1 db 0xff,0x25,',1',0_movi db 0xff,0x3d,' ',0xff,0x0b,',',0xff,0x17,'[',0xff,0x23,']',0_mova db 0xff,0x3d,' ',0xff,0x17,'[',0xff,0x23,'],',0xff,0x0b,0_movrb db 0xff,0x3d,' ',0xff,0x10,',',0xff,0x08,0_movrv db 0xff,0x3d,' ',0xff,0x0e,',',0xff,0x09,0_movmr db 0xff,0x22,' ',0xff,0x21,0_movsm db 0xff,0x22,' ',0xff,0x2d,0_movmi db 0xff,0x22,' ',0xff,0x16,',',0xff,0x07,0_una db 0xff,0x27,0 ; nao precisa do zero..._indfe db 0xff,0x48,0 ; nao precisa do zero final_indff db 0xff,0x3b,0_imulv db 'imul ',0xff,0x2a,'*',0xff,0x09,0_imulb db 'imul ',0xff,0x2a,'*',0xff,0x08,0_rep db 'rep',0xff,0x2e,0_lock db 'lock ',0xff,0x46,0

mpu db 0xff,0x40,0 ; usada em todos os oitosendereços

; instruções inc, dec, call, callfar..._incx db 'inc ',0xff,0x3a,0,0 ; deixar 2 zeros_decx db 'dec ',0xff,0x3a,0,0 ; deixar 2 zeros

Page: 44


_callx db 'call', 0xff,0x3a,0,0 ; deixar 2 zeros_callfarx db 'call far ',0xff,0x37,0,0 ; deixar 2 zeros_jmpx db 'jmp',0xff,0x3a,0,0 ; deixar 2 zeros_jmpfarx db 'jmp far ',0xff,0x37,0,0 ; deixar 2 zeros_pusx db 0xff,0x3f,' ',0xff,0x3c,0,0 ; deixar 2 zeros

_a32 db 0xff,0x02 ; não precisa zero no final_o32 db 0xff,0x01 ; idem_of db 0xff,0x05 ; idem_rseg0 db 0xff,0x03 ; idem_rseg1 db 0xff,0x04 ; idem_cbwm db 0xff,0x19 ; idem, usa o loop da rotina principal, só altera si.

; instruções de dois bytes_clts db 'clts',0_loadall db 'loadall',0_load286 db 'loadall286',0

; (todas as expressões devem ter a mesma extensão em bytes, exceto o último (8 ao todo); usa _0f00 para buscar o grupo todogrupo6 db 'sldt ',0xff,0x36,0 ;8 db 'str ',0xff,0x36,0,0 ;8 db 'lldt ',0xff,0x36,0 ;8 db 'ltr ',0xff,0x36,0,0 ;8 db 'verr ',0xff,0x36,0 ;8 db 'verw ',0xff,0x36,0 ;8 db 0xff,0x38,0,'@@' ; imprime instrução inválida @=bytes livres_i0f00 db 0xff,0x35,0 ; ocupa os dois bytes subtraidos da expressão anterior, paraeconomizer espaço db 'inv pg486',0 ;a

; (todas as expressões devem ter a mesma extensão em bytes, exceto o último (8 ao todo); usa _0f01 para buscar o grupo todogrupo7 db 'sgdt ',0xff,0x37,0 db 'sidt ',0xff,0x37,0 db 'lgdt ',0xff,0x37,0 db 'lidt ',0xff,0x37,0 db 'smsw ',0xff,0x36,0 db 0xff,0x38,0,'@@' ; @= bytes livres_i0f01 db 0xff,0x39,0 ; ocupa os dois bytes subtraidos da expressão anterior, paraeconomizer espaço db 'lmsw ',0xff,0x36,0 db 0xff,0x38,0

_lsl db 'lsl ',0xff,0x2a,0_lar db 'lar ',0xff,0x2a,0_bsf db 'bsf ',0xff,0x2a,0_bsr db 'bsr ',0xff,0x2a,0_imul db 'imul ',0xff,0x2a,0

_jccnear db 'j',0xff,0x11,' ',0xff,0x1b,0_set db 'set',0xff,0x11,' ',0xff,0x13,0

_lss db 'lss ',0xff,0x2b,0_lfs db 'lfs ',0xff,0x2b,0_lgs db 'lgs ',0xff,0x2b,0

_umov db 'umov ',0xff,0x21,0_pushfs db 0xff,0x3f,' ',0xff,0x1d,0 ; Serve também para push gs_popfs db 0xff,0x3e,' ',0xff,0x1d,0 ; Serve também para pop gs_bt db 'bt',0xff,0x33,' ',0xff,0x31,0_bti db 'bt',0xff,0x34,' ',0xff,0x3a,'.',0xff,0x08,0_movzx db 0xff,0x3d,'zx ',0xff,0x30,0_movsx db 0xff,0x3d,'sx ',0xff,0x30,0_shld db 'shld ',0xff,0x31,',',0xff,0x32,0_shrd db 'shrd ',0xff,0x31,',',0xff,0x32,0

Page: 45


_cr db 0xff,0x44,' cr',0xff,0x2f,',',0xff,0x0e,0_crr db 0xff,0x44,' ',0xff,0x0e,', cr',0xff,0x2f,0_dr db 0xff,0x44,' dr',0xff,0x2f,',',0xff,0x0e,0_drr db 0xff,0x44,' ',0xff,0x0e,', dr',0xff,0x2f,0_tr db 0xff,0x44,' tr',0xff,0x2f,',',0xff,0x0e,0_trr db 0xff,0x44,' ',0xff,0x0e,', tr',0xff,0x2f,0

; instruções 486_wbinvd db 'wbinvd',0_invd db 'invd',0_bswap db 'bswap ',0xff,0x12,0_xadd db 'xadd ',0xff,0x21,0_cmpxchg486 db 'cmpxchg ',0xff,0x21,0

; instruções fpu_fadd_single_real db 'fadd dd ',0_fmul_single_real db 'fmul dd ',0_fcom_single_real db 'fcom dd ',0_fcomp_single_real db 'fcomp dd ',0_fsub_single_real db 'fsubr dd ',0_fsubr_single_real db 'fsubr dd ',0_fdiv_single_real db 'fdiv dd ',0_fdivr_single_real db 'fdivr dd',0_fld_single_real db 'fld dd ',0_fst_single_real db 'fst dd ',0_fstp_single_real db 'fstp dd ',0

_fadd_doble_real db 'fadd qw ',0_fmul_doble_real db 'fmul qw ',0_fcom_doble_real db 'fcom qw ',0_fcomp_doble_real db 'fcomp qw ',0_fsub_doble_real db 'fsub qw ',0_fsubr_doble_real db 'fsubr qw ',0_fdiv_doble_real db 'fdiv qw ',0_fdivr_doble_real db 'fdivr qw ',0_fld_doble_real db 'fld qw ',0_fst_doble_real db 'fst qw ',0_fstp_doble_real db 'fstp qw ',0

_fiadd_wo_Int db 'fiadd wo ',0_fimul_wo_Int db 'fimul wo ',0_ficom_wo_Int db 'ficom wo ',0_ficomp_wo_Int db 'ficomp wo ',0_fisub_wo_Int db 'fisub wo ',0_fisubr_wo_Int db 'fisubr wo ',0_fidiv_wo_Int db 'fidiv wo ',0_fidivr_wo_Int db 'fidivr wo ',0_fild_wo_Int db 'fild wo ',0_fist_wo_Int db 'fist wo ',0_fistp_wo_Int db 'fistp wo ',0

_fiadd_dd_Int db 'fiadd qw ',0_fimul_dd_Int db 'fimul qw ',0_ficom_dd_Int db 'ficom qw ',0_ficomp_dd_Int db 'ficomp qw ',0fisub_dd_Int db 'fisub qw ',0fisubr_dd_Int db 'fisubr qw',0fidiv_dd_Int db 'fidiv qw ',0fidivr_dd_Int db 'fidivr qw ',0fild_dd_Int db 'fild dd ',0fist_dd_Int db 'fist dd ',0fistp_dd_Int db 'fistp dd ',0

fld_ext_real db 'fld tb ',0fstp_ext_real db 'fstp tb ',0

_fbld_pack_bcd db 'fbld ',0

Page: 46


_fbstp_pack_bcd db 'fbstp ',0

_fild_qw_Int db 'fild qw ',0_fistp_qw_Int db 'fistp qw ',0

_fldenv db 'fldenv ',0_fldcw_2bytes db 'fldcw ',0_fstenv db 'fstenv ',0_fstcw_2bytes db 'fstcw ',0_frstor db 'frstor ',0_fsave db 'fsave ',0_fstsw db 'fstsw ',0

vazio db 'esc',0

_fadd_sti db 'fadd ',0xff,0x41,0_fcom_sti db 'fcom ',0xff,0x41,0_fsub_sti db 'fsub ',0xff,0x41,0_fdiv_sti db 'fdiv ',0xff,0x41,0_fmul_sti db 'fmul ',0xff,0x41,0_fcomp_sti db 'fcomp ',0xff,0x41,0_fsubr_sti db 'fsubr ',0xff,0x41,0_fdivr_sti db 'fdivr ',0xff,0x41,0_fld_sti db 'fld ',0xff,0x41,0_fxch_sti db 'fxch ',0xff,0x41,0_fcmovb_sti db 'fcmovb ',0xff,0x41,0_fcmovbe_sti db 'fcmovbe ',0xff,0x41,0_fcmove_sti db 'fcmove ',0xff,0x41,0_fcmovu_sti db 'fcmovu ',0xff,0x41,0_fcmovnb_sti db 'fcmovnb ',0xff,0x41,0_fcmovnbe_sti db 'fcmovnbe ',0xff,0x41,0_fcomi_sti db 'fcomi ',0xff,0x41,0_fcmovne_sti db 'fcmovne ',0xff,0x41,0_fcmovnu_sti db 'fcmovnu ',0xff,0x41,0_fucomi_sti db 'fucomi ',0xff,0x41,0_fcomip_sti db 'fcomip ',0xff,0x41,0_fucomip_sti db 'fucomip ',0xff,0x41,0

_fadd_st0 db 'fadd ',0xff,0x42,0_fsubr_st0 db 'fsubr ',0xff,0x42,0_fdivr_st0 db 'fdivr ',0xff,0x42,0_fmul_st0 db 'fmul ',0xff,0x42,0_fsub_st0 db 'fsub ',0xff,0x42,0_fdiv_st0 db 'fdiv ',0xff,0x42,0_fucom_st0 db 'fucom ',0xff,0x42,0

_faddp_st0 db 'faddp ',0xff,0x42,0_fsubrp_st0 db 'fsubrp ',0xff,0x42,0_fdivrp_st0 db 'fdivrp ',0xff,0x42,0_fmulp_st0 db 'fmulp ',0xff,0x42,0_fsubp_st0 db 'fsubp ',0xff,0x42,0_fdivp_st0 db 'fdivp ',0xff,0x42,0

_ffree_sti db 'ffree ',0xff,0x43,0_fst_sti db 'fst ',0xff,0x43,0_fstp_sti db 'fstp ',0xff,0x43,0_fucomp_sti db 'fucomp ',0xff,0x43,0

_fcompp db 'fcompp',0_fucompp db 'fucompp',0_fstsw_ax db 'fstsw ax',0_fnop db 'fnop',0_fchs db 'fchs',0_fabs db 'fabs',0_ftst db 'ftst',0_fxam db 'fxam',0_f2xm1 db 'f2xm1',0

Page: 47


_fyl2x db 'fyl2x',0_fptan db 'fptan',0_fpatan db 'fpatan',0_fxtract db 'fxtract',0_fprem1 db 'fprem1',0_fdecstp db 'fdecstp',0_fincstp db 'fincstp',0_fld1 db 'fld 1',0_fldl2t db 'fld L2T',0_fldl2e db 'fld L2e',0_fldpi db 'fld pi',0_fldlg2 db 'fld Lg2',0_fldln2 db 'fld ln2',0_fldz db 'fld 0',0_fprem db 'fprem',0_fyl2xp1 db 'fyl2xp1',0_fsqrt db 'fsqrt',0_fsincos db 'fsincos',0_frndint db 'frndint',0_scale db 'fscale',0_fsin db 'fsin',0_fcos db 'fcos',0_fclex db 'fclex',0_finit db 'finit',0

; Instruções p5_cpuid db 'cpuid',0_emms db 'emms',0_rdmsr db 'rdmsr',0_rdtsc db 'rdtsc',0_rsm db 'rsm',0_wrmsr db 'wrmsr',0_cmpxchg db 'cmpxchg ',0xff,0x21,0

; instruções mmx_psubb db 'psubb ',0xff,0x49,0_psubw db 'psubw ',0xff,0x49,0_psubd db 'psubd ',0xff,0x49,0_psubsb db 'psubsb ',0xff,0x49,0_psubsw db 'psubsw ',0xff,0x49,0_psubusb db 'psubusb ',0xff,0x49,0_psubusw db 'psubusw ',0xff,0x49,0

_packssdd db 'packssdd ',0xff,0x49,0_packsswb db 'packsswb',0xff,0x49,0_packuswb db 'packuswb',0xff,0x49,0

_paddb db 'paddb ',0xff,0x49,0_paddd db 'paddd ',0xff,0x49,0_paddsb db 'paddsb ',0xff,0x49,0_paddsw db 'paddsw ',0xff,0x49,0_paddusb db 'paddusb ',0xff,0x49,0_paddusw db 'paddusw ',0xff,0x49,0

_pand db 'pand ',0xff,0x49,0_pandn db 'pandn ',0xff,0x49,0

_paveb db 'paveb ',0xff,0x49,0

_pcmpeqb db 'pcmpeqb ',0xff,0x49,0_pcmpeqw db 'pcmpeqw ',0xff,0x49,0_pcmpeqd db 'pcmpeqd ',0xff,0x49,0_pcmpgtb db 'pcmpgtb ',0xff,0x49,0_pcmpgtw db 'pcmpgtw ',0xff,0x49,0_pcmpgtd db 'pcmpgtd ',0xff,0x49,0

_pmadddd db 'pmadddd ',0xff,0x49,0

Page: 48


_pmulhw db 'pmulhw ',0xff,0x49,0_pmullw db 'pmullw ',0xff,0x49,0

_por db 'por ',0xff,0x49,0_pxor db 'pxor ',0xff,0x49,0

_punpckhbw db 'punpckhbw ',0xff,0x49,0_punpckhwd db 'punpckhwd ',0xff,0x49,0_punpckhdq db 'punpckhdq ',0xff,0x49,0_punpcklbw db 'punpcklbw ',0xff,0x49,0_punpcklwd db 'punpcklwd ',0xff,0x49,0_punpckldq db 'punpckldq ',0xff,0x49,0

_movq db 'movq ',0xff,0x49,0_movqr db 'movq ',0xff,0x4a,0_movd db 'movd ',0xff,0x4b,0_movdr db 'movd ',0xff,0x4c,0

_psllw db 'psllw ',0xff,0x49,0_pslld db 'pslld ',0xff,0x49,0_psllq db 'psllq ',0xff,0x49,0_psrlw db 'psrlw ',0xff,0x49,0_psrld db 'psrld ',0xff,0x49,0_psrlq db 'psrlq ',0xff,0x49,0_psraw db 'psraw ',0xff,0x49,0_psrad db 'psrad ',0xff,0x49,0

_psllwi db 'psllw ',0xff,0x50,0_pslldi db 'pslld ',0xff,0x50,0_psllqi db 'psllq ',0xff,0x50,0_psrlwi db 'psrlw ',0xff,0x50,0_psrldi db 'psrld ',0xff,0x50,0_psrlqi db 'psrlq ',0xff,0x50,0_psrawi db 'psraw ',0xff,0x50,0_psradi db 'psrad ',0xff,0x50,0_gr121314 db 0xff,0x47 ; busca ponteiro dos grupos 12, 13 e 14

; instruções p6_int1 db 'int1',0_rdpmc db 'rdpmc',0_cmov db 'cmov ',0xff,0x11,' ', 0xff,0x2a,0

; instruções mmx extendidas e outras mais recentes...falta implementar

Page: 49

Education

C. Bombardelli - Desassembler routine in text mode built in assembly language