Este documento descreve um código assembly para desassemblar instruções Intel/AMD. Ele fornece rotinas para ler o código de máquina e imprimir a representação assembly correspondente na memória. As rotinas auxiliares tratam da impressão de operandos, registradores e prefixos de segmento de acordo com os bits de controle armazenados em CH. O programa funciona lendo bytes de código sequencialmente e chamando as rotinas FF apropriadas.

1. File: C:PGMdesa_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

2. File: C:PGMdesa_prg32 COMPLETO.cb
; ROTINA PRINCIPAL
align 4
desa_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

3. File: C:PGMdesa_prg32 COMPLETO.cb
; ROTINAS AUXILIARES
align 4
opcode_cont dd 0
buffer_opcode rb 0xf
imp_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 4
imp_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 4
imp_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 4
Imp_al:
mov [edi], al
inc edi
inc edi
retn
align 4
imp_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

4. File: C:PGMdesa_prg32 COMPLETO.cb
call Imp_al
xchg ah,al
call Imp_al
retn
align 4
imp_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 4
imp_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 4
imp_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 4
desa01 : ; 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 4
desa02 : ; 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

5. File: C:PGMdesa_prg32 COMPLETO.cb
jmp continue ; continue: busca novo byte de código
ret
align 4
desa03 : ; 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 4
desa04 : ; 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 4
desa05 : ; 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 4
desa06 : ; 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 4
desa09 : ; 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

6. File: C:PGMdesa_prg32 COMPLETO.cb
call imp_ddhex ; Imprime id hex
ret
align 4
desa0a : ; 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 4
desa07 : ; 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 4
desa23 : ; 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 4
desa0b : ; 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 4
desa0f : ; 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 4
desa15 : ; Imprime D, em função do prefixo 66 test ch, 0x40
je .a
mov al, 'd'
call Imp_al
.a: ret
align 4
desa32 : ; Imprime ib ou cl
test ch, 0x8
je desa06
push esi
mov esi, reg8+0x3
call imp_stringzGS
pop esi
ret
align 4
desa0e : ; Escolhe e imprime rv em função de #6[ch] e #0,1,2[cl]
Page: 6

7. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa10 : ; 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 4
desa11 : ; 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 4
desa18 : ; 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 4
rmb_rmv : ; Busca byte rm e escolhe rmb / rmv ou rb / rv em função de #0[cl]
test cl, 1
je desa13
or ch, 0x20
desa13 : ; Busca byte rm e escolhe rmb / rmv ou rb / rv (memória ou registrador)
mov al, [ebx]
call imp_opcodehex
inc ebx
mov cl, al
rmv : ; Escolhe rmb / rmv ou rb / rv
xor al, 0xc0 ; verifica se #6,7 = 11 - end. por registrador
Page: 7

8. File: C:PGMdesa_prg32 COMPLETO.cb
test al, 0xc0
je rv
memv : ; 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
ret
rv : ; Escolhe rb ou rv (escolhe registrador)
test ch, 0x20
jne near desa0e ; Imprime rv
jmp desa10 ; Imprime rb
align 4
aux_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 4
desa3a : ; 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 4
desa16 : ; 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 4
aux16 :
push esi
Page: 8

9. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa17 : ; 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 4
aux17 : push esi ; Imprime registrador de segmento
mov esi, regseg - 0x3
jmp desa10.b
align 4
desa19 : ; 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 4
desa1a : ; 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 4
desa1b : ; 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 4
desa1c : ; Imprime es, cs, ss ou ds (OK 30/01/01 15:43)
push esi
Page: 9

10. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa1d : ; 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 4
desa1e : ; 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 4
desa1f : ; 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 4
desa20 : ; 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 4
desa21: ; 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

11. File: C:PGMdesa_prg32 COMPLETO.cb
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_reg
R_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 4
desa22 : ; 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 4
desa24: ; 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 4
desa25: ; 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 4
aux25 : ; Busca nome das instruções do grupo 2
push esi
mov esi, grupo2
jmp desa20.b
align 4
desa26 : ; Imprime aviso3 (para ser usada somente internamente à rotina aux_busca (ver grupo3))
Page: 11

12. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa27 : ; 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 4
desa28 : ; 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

13. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa2a: ; Executa rotina 21 com #5[ch]=1.
or ch, 0x10 ; Referencia incondicional à memoria tipo rv,rmv
jmp desa21.c
align 4
desa2b : ; 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

14. File: C:PGMdesa_prg32 COMPLETO.cb
mov esi, aviso5
call imp_stringzGS
pop esi
or dh, 0x01 ; marcação de erro para acionar cy=1 na saida
ret
align 4
desa2c: ; Executa rotina 21 com #6[ch]=0. usada pela instrução "arpl"
and ch, 0xbf
jmp desa21.a
align 4
desa2d : ; 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_al
aux2d: 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 4
desa2e : ; 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

15. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa30 : ; 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 4
desa31 : ; 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 4
desa33 : ; 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 4
desa34 : ; 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

16. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa35 : ; 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 bloco
grupo6
add esi, eax
call aux_busca.a
pop esi
ret
align 4
desa36 : ; 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 4
desa37 : ; 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 referenciar
registrador
jmp rmv ; busca modo de endereçamento
align 4
desa38 : ; Imprime "Instrução inválida"
push esi
mov esi, aviso1
call imp_stringzGS
pop esi
or dh, 0x01 ; posiciona marca para erro
ret
align 4
desa39 : ; 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 4
desa3b : ; Busca byte rm e escolhe uma das instruções do grupo 5
Page: 16

17. File: C:PGMdesa_prg32 COMPLETO.cb
or ch, 0x20
mov esi, grupo5
mov al, [ebx]
call imp_opcodehex
inc ebx
mov cl, al
jmp aux4d
align 4
desa3c : ; Imprime rmv (usada pela instrução push rmv do grupo 5)
or ch, 0x20
jmp desa16.b
align 4
desa44 : ; 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 4
desa3e : ; Imprime 'pop'
push esi
mov esi, _pop
call imp_stringzGS
pop esi
ret
align 4
desa3f : ; Imprime 'push'
push esi
mov esi, _push
call imp_stringzGS
pop esi
ret
align 4
desa0c : ; 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

18. File: C:PGMdesa_prg32 COMPLETO.cb
ret
align 4
desa0d : ; 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 4
desa40 : ; 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 4
desa41 : ; 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 4
desa42 : ; Imprime "stx,st0" em função de #0,1,2[cl]
push esi
Page: 18

19. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa43 : ; 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 esi
R_ret: ret
align 4
desa45 : ;.Marca erro posicionando #1[dh]=1
or dh, 0x1
ret
align 4
desa46 : ; Marca #2[dh]=1 e continua. Rotina especifica para instrução lock
or dh, 0x2
add esp, 0x4
jmp continue
align 4
desa47 : ; 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 4
desa2f : ; 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

20. File: C:PGMdesa_prg32 COMPLETO.cb
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 4
desa14 : ; 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 4
desa12 : ; 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 4
desa48 : ; 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 4
desa49 : ; Busca byte rm para instruções mmx (rmmx, rmmx/m64)
mov al, [ebx]
Page: 20

21. File: C:PGMdesa_prg32 COMPLETO.cb
call imp_opcodehex
inc ebx
mov cl, al
shr al, 3
call rmmx
mov al, ','
call Imp_al
mov al, cl
aux4a: xor al,0xc0
test al,0xc0
je near memv ; Escolhe memória
rmmx: 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 4
desa4a : ; 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 4
desa4b : ; 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 4
desa4c : ; 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 4
desa4d : ; Busca ponteiro para instruções do grupo 12
mov esi, grupo12
aux4d:
and eax, 0x38
shr al, 1
Page: 21

22. File: C:PGMdesa_prg32 COMPLETO.cb
add esi, eax
call aux_busca
ret
align 4
desa4e : ; Busca ponteiro para instruções do grupo 13
mov esi, grupo13
jmp aux4d
align 4
desa4f : ; Busca ponteiro para instruções do grupo 14
mov esi, grupo14
jmp aux4d
align 4
desa50 : ; 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 FF
align 4
base_rotinas_ff:
dd desa01 ; Marca prefixo de tamanho de operando
dd desa02 ; Marca prefixo de tamanho de endereço
dd desa03 ; Marca prefixo de segmento es, cs, ss ou ds
dd desa04 ; Marca prefixo de segmento fs ou gs
dd desa05 ; Marca instrução com dois bytes, busca opcode na tabela seguinte
dd 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 ib
dd desa09 ; Escolhe e imprime iw ou id em função de #6[ch]
dd desa0a ; Imprime iw
dd 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 eax
dd desa10 ; Escolhe e imprime rb em função de #0,1,2[cl]
dd desa11 ; Escolhe e imprime condição
dd 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 sib
dd desa15 ; Imprime D, em função do prefixo 66
dd desa16 ; Imprime rmb ou rmv com prefixo de segmento + by, wo ou dd
dd desa17 ; Imprime prefixo de segmento em função #0,1,2[ch]
dd desa18 ; Imprime b, w ou d
dd desa19 ; Altera "si" para buscar uma das quatro : "cbw", "cwde", "cwd" ou "cdq"
dd desa1a ; Imprime endereço relativo curto
dd desa1b ; Imprime endereço relativo longo variável
dd desa1c ; Imprime es, cs, ss ou ds
dd desa1d ; Imprime fs ou gs
dd desa1e ; Imprime cx ou ecx
dd desa1f ; Imprime ne ou e
dd 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,rb
dd desa22 ; Imprime 'mov' setando #5[ch] se #0[cl]=1
Page: 22

23. File: C:PGMdesa_prg32 COMPLETO.cb
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, sar
dd 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 imediato
dd desa29 ; Busca deslocamento nos modos de endereçamento
dd desa2a ; Executa rotina 21 com #5[ch]=1. Referencia à memoria tipo rv,rmv incondicional
dd 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 7
dd desa30 ; Rotina especifica para as instruções movsx e movzx
dd desa31 ; Busca byte rm para end tipo rmv,rv. marca #3[ch]=1 se #0[byte anterior]=1
dd 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 8
dd 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ção
dd 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 5
dd 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]=1
dd desa45 ; Marca erro posicionando #1[dh]=1
dd desa46 ; Marca #2[dh]=1 e continua. Rotina especifica para instrução lock
dd desa47 ; Busca byte rm para instruções dos grupos 12, 13 e 14
dd desa48 ; Busca byte rm e escolhe umas das instruções do grupo 4
dd 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 12
dd desa4e ; Busca ponteiro para instruções do grupo 13
dd desa4f ; Busca ponteiro para instruções do grupo 14
dd 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

24. File: C:PGMdesa_prg32 COMPLETO.cb
grupo4 dd _incx
dd _decx
dd livre
dd livre
dd livre
dd livre
dd livre
grupo4.7 dd livre
grupo5 dd _incx
dd _decx
dd _callx
dd _callfarx
dd _jmpx
dd _jmpfarx
dd _pusx
grupo5.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 16
base_indices:
dd _add ; 00- add rmb,rb
dd _add ; 01- add rmv,rv
dd _add ; 02- add rb,rmb
dd _add ; 03- add rv,rmv
dd _addi ; 04- add al,ib ; a mesma rotina serve para os códigos 04 e 05
dd _addi ; 05- add axv,iv
dd _pushs ; 06- push es
dd _pops ; 07- pop es
dd _add ; 08- or rmb,rb
dd _add ; 09- or rmv,rv
dd _add ; 0a- or rb,rmb
dd _add ; 0b- or rv,rmv
dd _addi ; 0c- or al,ib
Page: 24

25. File: C:PGMdesa_prg32 COMPLETO.cb
dd _addi ; 0d- or axv,iv
dd _pushs ; 0e- push cs
dd _of ; 0f- opcode 2 bytes
dd _add ; 10- adc rmb,rb
dd _add ; 11- adc rmv,rv
dd _add ; 12- adc rb,rmb
dd _add ; 13- adc rv,rmv
dd _addi ; 14- adc al,ib
dd _addi ; 15- adc axv,iv
dd _pushs ; 16- push ss
dd _pops ; 17- pop ss
dd _add ; 18- sbb rmb,rb
dd _add ; 19- sbb rmv,rv
dd _add ; 1a- sbb rb,rmb
dd _add ; 1b- sbb rv,rmv
dd _addi ; 1c- sbb al,ib
dd _addi ; 1d- sbb axv,iv
dd _pushs ; 1e- push ds
dd _pops ; 1f- pop ds
dd _add ; 20- and rmb,rb
dd _add ; 21- and rmv,rv
dd _add ; 22- and rb,rmb
dd _add ; 23- and rv,rmv
dd _addi ; 24- and al,ib
dd _addi ; 25- and axv,iv
dd _rseg0 ; 26- prefixo es
dd _daa ; 27- daa OK 30/01/01 9:57
dd _add ; 28- sub rb,rmb
dd _add ; 29- sub rv,rmv
dd _add ; 2a- sub rmb,rb
dd _add ; 2b- sub rmv,rv
dd _addi ; 2c- sub al,ib
dd _addi ; 2d- sub axv, iv
dd _rseg0 ; 2e- prefixo cs
dd _das ; 2f- das OK 30/01/01 9:57
dd _add ; 30- xor rmb,rb
dd _add ; 31- xor rmv,rv
dd _add ; 32- xor rb,rmb
dd _add ; 33- xor rv,rmv
dd _addi ; 34- xor al,ib
dd _addi ; 35- xor axv,iv
dd _rseg0 ; 36- prefixo ss
dd _aaa ; 37- aaa OK 22/01/01 3:12
dd _add ; 38- cmp rmb,rb
dd _add ; 39- cmp rmv,rv
dd _add ; 3a- cmp rb,rmb
dd _add ; 3b- cmp rv,rmv
dd _addi ; 3c- cmp al,1b
dd _addi ; 3d- cmp axv,iv
dd _rseg0 ; 3e- prefixo ds
dd _aas ; 3f- aas OK 22/01/01 3:12
dd _inc ; 40- inc axv OK
dd _inc ; 41- inc cxv OK
dd _inc ; 42- inc dxv
dd _inc ; 43- inc bxv
dd _inc ; 44- inc spv
dd _inc ; 45- inc bpv
dd _inc ; 46- inc siv
dd _inc ; 47- inc div
dd _dec ; 48- dec axv OK
dd _dec ; 49- dec cxv
dd _dec ; 4a- dec dxv
dd _dec ; 4b- dec bxv
Page: 25

26. File: C:PGMdesa_prg32 COMPLETO.cb
dd _dec ; 4c- dec spv
dd _dec ; 4d- dec bpv
dd _dec ; 4e- dec siv
dd _dec ; 4f- dec div
dd _pushr ; 50- push axv
dd _pushr ; 51- push cxv
dd _pushr ; 52- push dxv
dd _pushr ; 53- push bxv
dd _pushr ; 54- push spv
dd _pushr ; 55- push bpv
dd _pushr ; 56- push siv
dd _pushr ; 57- push div
dd _popr ; 58- pop axv
dd _popr ; 59- pop cxv
dd _popr ; 5a- pop dxv
dd _popr ; 5b- pop bxv
dd _popr ; 5c- pop spv
dd _popr ; 5d- pop bpv
dd _popr ; 5e- pop siv
dd _popr ; 5f- pop div
dd _pusha ; 60- pushav
dd _popa ; 61- popav
dd _bound ; 62- bound rv,m2v
dd _arpl ; 63- afpl mw,rw
dd _rseg1 ; 64- prefixo fs
dd _rseg1 ; 65- prefixo gs
dd _o32 ; 66- prefixo de tamanho de operando
dd _a32 ; 67- prefixo de tamanho de endereçamento
dd _pushiv ; 68- push iv
dd _imulv ; 69- imul rv,rmv,iv
dd _pushib ; 6a- push ib
dd _imulb ; 6b- imul rv,rmv,ib
dd _ins ; 6c- insb
dd _ins ; 6d- insv
dd _outs ; 6e- outsb
dd _outs ; 6f- outsv
dd _jcc ; 70- jo short OK 23/01/01 15:05 (usa prefixo 66 para a32)
dd _jcc ; 71- jno short
dd _jcc ; 72- jb short OK 23/01/01 15:05
dd _jcc ; 73- jae short
dd _jcc ; 74- je short
dd _jcc ; 75- jne short
dd _jcc ; 76- jbe short
dd _jcc ; 77- ja short
dd _jcc ; 78- js short
dd _jcc ; 79- jns short
dd _jcc ; 7a- jpe short
dd _jcc ; 7b- jpo short
dd _jcc ; 7c- jl short
dd _jcc ; 7d- jge short
dd _jcc ; 7e- jle short
dd _jcc ; 7f- jg short
dd _imebb ; 80- grupo 1 - imediato rmb,ib
dd _imebb ; 81- grupo 1 - imediato rmb,iv
dd _imebb ; 82- grupo 1 - não usado
dd _imebv ; 83- grupo 1 - imediato rmv,ib
dd _testr ; 84- test rmb,rb
dd _testr ; 85- test rmv,rv
dd _xchgr ; 86- xchg rmb,rb
dd _xchgr ; 87- xchg rmv,rv
dd _movmr ; 88- mov rmb,rb
dd _movmr ; 89- mov rmv,rv
dd _movmr ; 8a- mov rmb,ib
Page: 26

27. File: C:PGMdesa_prg32 COMPLETO.cb
dd _movmr ; 8b- mov rmv,iv
dd _movsm ; 8c- mov rmw, segr
dd _lea ; 8d- lea rv,m
dd _movsm ; 8e- mov segr,mw
dd _poprm ; 8f- pop rmv
dd _nop ; 90- xchg eav,eav/nop OK 22/01/01 3:10
dd _xchg ; 91- xchg eav,ecv
dd _xchg ; 92- xchg eav,edv
dd _xchg ; 93- xchg eav,ebv
dd _xchg ; 94- xchg eav,spv
dd _xchg ; 95- xchg eav,bpv
dd _xchg ; 96- xchg eav,siv
dd _xchg ; 97- xchg eav,div
dd _cbwm ; 98- cbw/cwde
dd _cbwm ; 99- cwd/cdq
dd _calli ; 9a- call far direta
dd _fwait ; 9b- fwait OK 22/01/01 3:32
dd _pushf ; 9c- pushfv
dd _popf ; 9d- popfv
dd _sahf ; 9e- sahf OK 22/01/01 3:31
dd _lahf ; 9f- lahf OK 22/01/01 3:32
dd _movi ; a0- mov al,xb
dd _movi ; a1- mov axv,xv
dd _mova ; a2- mov xb,al
dd _mova ; a3- mov xv,axv
dd _movs ; a4- movsb
dd _movs ; a5- movsv
dd _cmps ; a6- cmpsb
dd _cmps ; a7- cmpsv
dd _testi ; a8- test al,ib
dd _testi ; a9- test axv,iv
dd _stos ; aa- stosb
dd _stos ; ab- stosv
dd _lods ; ac- lodsb
dd _lods ; ad- lodsv
dd _scas ; ae- scasb
dd _scas ; af- scasv
dd _movrb ; b0- mov al,ib
dd _movrb ; b1- mov cl,ib
dd _movrb ; b2- mov dl,ib
dd _movrb ; b3- mov bl,1b
dd _movrb ; b4- mov ah,ib
dd _movrb ; b5- mov ch,ib
dd _movrb ; b6- mov dh,ib
dd _movrb ; b7- mov bh,ib
dd _movrv ; b8- mov axv,iv
dd _movrv ; b9- mov cxv,iv
dd _movrv ; ba- mov dxv,iv
dd _movrv ; bb- mov bxv,iv
dd _movrv ; bc- mov spv,iv
dd _movrv ; bd- mov bpv,iv
dd _movrv ; be- mov siv,iv
dd _movrv ; bf- mov div,iv
dd _deslib ; c0- grupo 2 - desloc rmb,ib
dd _deslib ; c1- grupo 2 - desloc rmv,ib
dd _retiw ; c2- ret iw OK 23/01/01 10:10
dd _ret ; c3- ret (near) OK 22/01/01 3:33
dd _les ; c4- les rv,mp
dd _lds ; c5- lds rv,mp
dd _movmi ; c6- grupo 11 - mov rmb,ib
dd _movmi ; c7- grupo 11 - mov rmv,iv
dd _enter ; c8- enter iw,ib
dd _leave ; c9- leave OK 23/01/01 10:10
Page: 27

28. File: C:PGMdesa_prg32 COMPLETO.cb
dd _retfiw ; ca- retf iw
dd _retf ; cb- retf
dd _int3 ; cc- int3 OK 23/01/01 10:09
dd _intib ; cd- int ib OK 23/01/01 10:09
dd _into ; ce- into OK 23/01/01 10:10
dd _iret ; cf- iretv
dd _desl1 ; d0- grupo 2 - desloc rmb,1
dd _desl1 ; d1- grupo 2 - desloc rmv,1
dd _deslcl ; d2- grupo 2 - desloc rmb,cl
dd _deslcl ; d3- grupo 2 - desloc rmv,cl
dd _aam ; d4- aam (ib)
dd _aad ; d5- aad (ib)
dd _salc ; d6- set al from carry flag, não documentada
dd _xlatb ; d7- xlatb
dd mpu ; d8- instrução mpu
dd mpu ; d9- instrução mpu
dd mpu ; da- instrução mpu
dd mpu ; db- instrução mpu
dd mpu ; dc- instrução mpu
dd mpu ; dd- instrução mpu
dd mpu ; de- instrução mpu
dd mpu ; df- instrução mpu
dd _loopc ; e0- loopne short
dd _loopc ; e1- loope short
dd _loop ; e2- loop short
dd _jcxz ; e3- jcxv short
dd _in ; e4- in al,ib
dd _in ; e5- in axv,ib
dd _out ; e6- out al,ib
dd _out ; e7- out axv,ib
dd _call ; e8- call near
dd _jmp ; e9- jmp near
dd _jmpf ; ea- jmp far
dd _jmps ; eb- jmp short
dd _indx ; ec- in al,dx
dd _indx ; ed- in axv,dx
dd _outdx ; ee- out al,dx
dd _outdx ; ef- out axv,dx
dd _lock ; f0- prefixo lock
dd _int1 ; f1- int1 (P6)
dd _rep ; f2- prefixo repne
dd _rep ; f3- prefixo repe/rep
dd _hlt ; f4- hlt
dd _cmc ; f5- cmc
dd _una ; f6- grupo 3 - unário mb
dd _una ; f7- grupo 3 - unário mv
dd _clc ; f8- clc
dd _stc ; f9- stc
dd _cli ; fa- cli
dd _sti ; fb- sti
dd _cld ; fc- cld
dd _std ; fd- std
dd _indfe ; fe- grupo 4 - inc/dec rmb
dd _indff ; ff- grupo 5 - indireto
; tabela do segundo byte
dd _i0f00 ; 0f 00- grupo 6 - instruções 0f 00
dd _i0f01 ; 0f 01- grupo 7 - instruções 0f 01
dd _lar ; 0f 02- lar rv,rmv
dd _lsl ; 0f 03- lsl rv, rmv
dd livre ; 0f 04- *
dd _load286 ; 0f 05- loadall286 (286, não doc)
dd _clts ; 0f 06- clts
dd _loadall ; 0f 07- loadall (386, não doc)
Page: 28

29. File: C:PGMdesa_prg32 COMPLETO.cb
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,crn
dd _drr ; 0f 21- mov rd,drn
dd _cr ; 0f 22- mov crn,rd
dd _dr ; 0f 23- mov drn,rd
dd _trr ; 0f 24- mov rd,trn
dd livre ; 0f 25- *
dd _tr ; 0f 26- mov trn,rd
dd 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

30. File: C:PGMdesa_prg32 COMPLETO.cb
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 shift
dd _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 near
dd _jccnear ; 0f 81- jno near
dd _jccnear ; 0f 82- jb near
dd _jccnear ; 0f 83- jae near
dd _jccnear ; 0f 84- je near
dd _jccnear ; 0f 85- jne near
Page: 30

31. File: C:PGMdesa_prg32 COMPLETO.cb
dd _jccnear ; 0f 86- jbe near
dd _jccnear ; 0f 87- ja near
dd _jccnear ; 0f 88- js near
dd _jccnear ; 0f 89- jns near
dd _jccnear ; 0f 8a- jpe near
dd _jccnear ; 0f 8b- jpo near
dd _jccnear ; 0f 8c- jl near
dd _jccnear ; 0f 8d- jge near
dd _jccnear ; 0f 8e- jle near
dd _jccnear ; 0f 8f- jg near
dd _set ; 0f 90- seto rmb
dd _set ; 0f 91- setno rmb
dd _set ; 0f 92- setb rmb
dd _set ; 0f 93- setae rmb
dd _set ; 0f 94- sete rmb
dd _set ; 0f 95- setne rmb
dd _set ; 0f 96- setbe rmb
dd _set ; 0f 97- seta rmb
dd _set ; 0f 98- sets rmb
dd _set ; 0f 99- setns rmb
dd _set ; 0f 9a- setpe rmb
dd _set ; 0f 9b- setpo rmb
dd _set ; 0f 9c- setl rmb
dd _set ; 0f 9d- setge rmb
dd _set ; 0f 9e- setle rmb
dd _set ; 0f 9f- setg rmb
dd _pushfs ; 0f a0- push fs
dd _popfs ; 0f a1- pop fs
dd _cpuid ; 0f a2- cpuid (p5)
dd _bt ; 0f a3- bt rm, rv
dd _shld ; 0f a4- shld rmv,rv, ib
dd _shld ; 0f a5- shld rmv,rv, cl
dd _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 gs
dd _popfs ; 0f a9- pop gs
dd _rsm ; 0f aa- rsm (p5)
dd _bt ; 0f ab- bts rm, rv
dd _shrd ; 0f ac- shrd rmv,rv,ib
dd _shrd ; 0f ad- shrd rmv,rv,cl
dd 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,mp
dd _bt ; 0f b3- btr rm, rv
dd _lfs ; 0f b4- lfs rv,mp
dd _lgs ; 0f b5- lgs rv,mp
dd _movzx ; 0f b6- movzx rv,rmb
dd _movzx ; 0f b7- movzx rd,rmw
dd aviso4 ; 0f b8-
dd aviso4 ; 0f b9-
dd _bti ; 0f ba- grupo 8 - bloco de instruções btx rv/m,ib
dd _bt ; 0f bb- btc rm,rv
dd _bsf ; 0f bc- bsf rv,rmv
dd _bsr ; 0f bd- bsr rv,rmv
dd _movsx ; 0f be- movsx rv,rmb
dd _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

32. File: C:PGMdesa_prg32 COMPLETO.cb
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

33. File: C:PGMdesa_prg32 COMPLETO.cb
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

34. File: C:PGMdesa_prg32 COMPLETO.cb
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

35. File: C:PGMdesa_prg32 COMPLETO.cb
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

36. File: C:PGMdesa_prg32 COMPLETO.cb
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

37. File: C:PGMdesa_prg32 COMPLETO.cb
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