Um guia para o DEBUG Página: The Starman's Realm Assembly (somente em inglês)
A P Ê N D I C E S
para
Um guia para o DEBUG
( Programa Microsoft® DEBUG.EXE )
Direitos reservados©2004,2007,2009,2017 para Daniel B. Sedory
Esta página pode ser copiada gratuitamente apenas para uso pessoal !
( Não pode ser usada para qualquer outro propósito, a menos que você tenha
primeiro contatado (somente em inglês) e tenha recebido permissão do autor ! )
Primeiro, uma rápida revisão de como os números binários e hexadecimais estão relacionados: Quando os uns e zeros de quatro bits binários são agrupados (de 0000 até 1111muitas vezes chamados de nibble), eles podem ser representados por um único dígito hexadecimal (de 0 até F); ambos são usados para contar de 0 a 15 em decimais. Oito bits binários (que permitem qualquer valor decimal de 0 a 255) são representados por dois dois dígitos hexadecimais; por exemplo, o número binário 10101010 é igual a AA em hexadecimal. Números hexadecimais de dois dígitos (ou números binários de 8 bits) são chamados bytes. Não importa quantos dígitos um número tem em binário ou hexadecimal, você pode alternar entre os dois agrupamentos e convertê-los a cada quatro bits binários para um dígito hexadecimal ou vice-versa. O equivalente hexadecimal de um binário de 12 bits deve ter 3 dígitos (por exemplo, 101010111100 = ABC hex), e o maior número decimal que pode ser representado por dezesseis bits binários (65,535) equivale a FFFF em hexadecimal.
Os quatro registradores principais (de 16 bits) em uma CPU 8086 são chamados: Registrador acumulador (AX), Registrador de base (BX), Regisytrador de contagem (CX) e Registrador de dados (DX). Cada um desses registradores tem uma metade alta (H) e baixa (L) de 8 bits, que pode armazenar um byte hexadecimal (1 byte = 8 bits binários). Cada uma dessas metades superior e inferior pode ser ser acessada separadamente pelo código do programa:
| AX: |
|
Accumulator | ||||||||||||
| BX: | Base Register | |||||||||||||
| CX: | Count Register | |||||||||||||
| DX: | Data Register | |||||||||||||
Os demais registradores de 16 bits (dois bytes) da CPU 8086 são:
|
Stack Pointer |
|||||
|
|
Base Pointer |
|||||
|
|
Índice de origem (Source Index) |
|||||
|
|
Destination Index |
|
|
|
Code Segment |
||||
|
|
Data Segment |
|||||
|
|
Stack Segment |
|||||
|
|
Extra Segment |
|
|
|
Instruction Pointer |
A CPU 8086 usa um método, o qual chado de estrutura de SEGMENT: OFFSET que sempre que precisa acessa os locais de memória ou Jump (salta) 64kb de um Segment para outro. Isto é feito combinando-se dois registradores de 16 bits para formar um segmento de 20 bits: valor de deslocamento (o que significa que pode acessar mais de 1 MB de memória desta forma). Para certos tipos de tarefas, os registros são frequentemente agrupados juntos da mesma forma, mas o programador ainda deve se certificar de que a CPU os usará conforme o esperado. Aqui estão algumas tarefas que são definidas pela própria CPU:
CS : IP Next Instruction
SS : SP Stack Pointer
Dois outros conjuntos que costumam ser usados juntos em operações com cadeias (strings) são:
DS : SI Source Index
ES : DI Destination Index
Os REGISTRADORES de "FLAGS"
Se você realmente tem a intenção de usar o MS-DEBUG (ou qualquer outro depurador!) para examinar as operações de programas Assembly, então eu aconselho você a copiar essas abreviações em notecards e tentar entender por que certos bits (sinalizadores) alteram ou não mudam no registro de cada instrução do programa que você está examinando. ( Certifique-se de estudar a tabela final abaixo se for ler livros que discutem o registro de sinalizadores de 16 bits mais recente. Depuradores de 32 bits mais recentes, como o da Borland Turbo Debugger, mostram os mesmos oito sinalizadores como DEBUG, mas usam outra abreviatura para o nome de Flag e apenas mostram se é 0 ou 1 bit.)
Este é um registro de 8 bits que tem 1 bit de dados para cada um dos oito "Flags" que devem ser interpretados da seguinte forma: Abreviatura de livros didáticos para as Flags => of df if sf zf af pf cf Se as FLAGS estiverem habilitadas [SET] (1), -- -- -- -- -- -- -- -- seriam assim ... => OV DN EI NG ZR AC PE CY Se as FLAGS estiverem desabilitadas [CLEARed] (0), seriam assim ... => NV UP DI PL NZ NA PO NC FLAGS SET (com bit 1) CLEARed (com bit 0) --------------- --------------- ------------------- Overflow of = OV (OVerflow) NV [No oVerflow] Direction df = DN (decrement) UP (increment) Interrupt if = EI (enabled) DI (disabled) Sign sf = NG (negative) PL (positive) Zero zf = ZR [zero] NZ [Not zero] Auxiliary Carry af = AC NA [No AC ] Parity pf = PE (even) PO (odd) Carry cf = CY [Carry] NC [No Carry] ============== As abreviações individuais parecem ter os seguintes significados: OV = OVerflow (transbordo, estouro de capacidade). NV = No oVerflow (sem transbordo, sem ocorrência de estouro). DN = DowN (ação descrescente). UP = (up) - increment (ação crescente). EI = Enable Interupt (interrupção habilitada). DI = Disable Interupt (interrupção desabilitada). NG = NeGative (valor negativo). PL = PLus (valor positivo) Estranha mistura de termos devido ao fato de que a paridade impar 'Odd Parity' é representada por PO (não sendo tão POsitivo), mas pode ser usado 'MI' para indicar MInus em vez de 'NeGative'. ZR = ZeRo (sinalização de valor zero). NZ = Not Zero (sinalização de não zero). AC = Auxiliary Carry (ação auxiliar para "empresta um"). NA = Not Auxiliary carry (ação auxiliar para "toma um"). PE = Parity Even (paridade par). PO = Parity Odd (paridade ímpar). CY = CarrY (efetua "vai um"). NC = No Carry (efetua "não vai um).
Como os sinalizadores (Flags) são definidos nos Registradores
Obs: A palavra set significa dizer que um bit está definido como 1, enquanto as palavras reset ou clear/ed significam que um bit está set (definido) como 0.
O sinalizador de Direção (bit 10; Set=Down, 0=Up) e Interrupt (bit 9; Set=Enabled, 0=Disabled) são um tanto óbvios. No entanto, os seguintes sinalizadores requerem uma explicação detalhada:
O sinalizador Overflow (OF; bit 11) é set é definido quando uma operação resulta em um estouro (signed overflow); que ocorre quando há um efeito de vai um (carry/borrow) para dentro, mas não para fora do bit de ordem superior (high-order), ou vice-versa (fora mas não para dentro). Portanto, para uma operação de 8, 16 ou 32 bits, OF só será desfinido se houver um estouro nos bits 7, 15 ou 31 para a respectiva operação (lembre-se, as contagens de bits começam com zero).
O sinalizador de sinal (Sign) (SF; bit 7) é definido apenas quando o bit de ordem superior de um resultado é definido. Portanto, para operações de 8, 16 ou 32 bits, SF só será definido se houver 1 no bit 7, 15 ou 31; portanto, ele tem o mesmo estado que o bit de ordem superior do resultado.
O sinalizador Zero (ZF; bit 6) é definido somente quando todos os bits do resultado são zero; caso contrário, ele é reiniciado.
O sinalizador Auxiliary (AF; bit 4) só é definido quando o bit 3 (independentemente do tamanho do operando) do resultado é executado durante a soma (carry out), ou emprestado um durante a subtração. AF geralmente é usado com quantidades BCD compactadas, mas ainda será definido sempre que as condições adequadas forem encontradas.
O sinalizador Parity (PF; bit 2) é definidos apenas quando os 8 bits de ordem inferior (independentemente do tamanho do operando) têm um número par de "1" bit (paridade par); é redefinido quando eles têm partidade ímpar..
O sinalizador de Carry (CF; bit 0) é definido quando uma operação resulta em um carry out - vai um(durante a adição), ou empresta um (durante a subtração) odo bit de ordem superior. Portanto, para operações de 8, 16 ou 32 bits, CF só será definido se houver um Carry no bit 7, 15 ou 31 para a respectiva operação.
Os novos registradores de "FLAGS"
Para ajudá-lo a entender a exibição no MS-DEBUG em comparação com quaisquer código Assembly que fazem referência a um registrador de FLAGS de 16 ou 32 bits, aqui está o layout dos primeiros 12 bits (11 - 0) para os registradores de FLAGS de 16 ou 32 bits mais recentes:
of df if tf sf zf af pf cf
-----------------------------------
Símbolos usados no MS-DEBUG
-----------------------------------
OV DN EI NG ZR AC PE CY ---> Quando bit sinalizado = 1
NV UP DI PL NZ NA PO NC ---> Quando bit sinalizado = 0
|xx|xx|xx|--|xx|xx| 0|xx| 0|xx| 1|xx| Newer Designations:
Bits: 11 10 9 8 7 6 5 4 3 2 1 0
| | | | | | | | | | | '--- CF - Carry Flag
| | | | | | | | | | '--- é sempre 1
| | | | | | | | | '--- PF - Parity Flag
| | | | | | | | '--- é sempre 0
| | | | | | | '--- AF - Auxiliary (Carry) Flag
| | | | | | '--- é sempre 0
| | | | | '--- ZF - Zero Flag
| | | | '--- SF - Sign Flag
| | | '--- (TF Trap Flag - não mostrado no MS-DEBUG)
| | '--- IF - Interrupt Flag
| '--- DF - Direction Flag
'--- OF - Overflow Flag
Exemplos Numéricos
Se uma instrução definida apenas com sinalização Zero (bit 6; ZF=1; ZR) e Parity (bit 2; PF=1; PE; Parity Even), isso resultará no seguinte número binário:
0100 0110 (Lembre-se, o bit 1 está sempre definido!), então isso resultaria em um hexadecimal 46 nos 'registradores de Flags'. Se cada um desses bits fosse definido, um de cada vez, a representação hexadecimal dos registradores de Flags seria a seguinte:
Bit 11 (of): 1000 0000 0010 = 802 - Overflow (OV)
Bit 10 (df): 0100 0000 0010 = 402 - Direction Down (DN)
Bit 9 (if): 0010 0000 0010 = 202 - Interrupt Enabled (EI)
Bit 7 (sf): 0000 1000 0010 = 82 - Sign Negative (NG)
Bit 6 (zf): 0000 0100 0010 = 42 - Zero (ZR)
Bit 4 (af): 0000 0001 0010 = 12 - Auxiliary Carry (AC)
Bit 2 (pf): 0000 0000 0110 = 06 - Parity Even (PE)
Bit 0 (cf): 0000 0000 0011 = 03 - Carry (CY)
of df if tf sf zf (0) af (0) PF (1) CF = 07
of df if tf sf zf (0) AF (0) pf (1) CF = 13
of df if tf sf ZF (0) af (0) PF (1) cf = 46
of df IF tf sf zf (0) af (0) PF (1) CF = 207
of df IF tf sf ZF (0) af (0) PF (1) cf = 246
of df IF tf sf ZF (0) af (0) PF (1) CF = 247
of df IF tf SF zf (0) af (0) pf (1) cf = 282
of DF IF tf SF zf (0) af (0) pf (1) cf = 682
Atualizado: 7 FEVEREIRO 2004; 20 MAIO 2013.
Última atualização: 9 JUNHO 2013.
Um guia para o DEBUG Página: The Starman's Realm Assembly (somente em inglês)