TRACE

f--------------------------------------------------------------------------



M Ó D U L O O P E R A C I O N A L T R A C E



--------------------------------------------------------------------------

PUBLICADO NA REVISTA MICRO SISTEMAS EDIÇÃO NR.63 (DEZEMBRO DE 1986)

--------------------------------------------------------------------------

AUTOR: RICARDO DE PAOLA

--------------------------------------------------------------------------

CONVERTIDO POR KELLY ABRANTES MURTA - BRASIL - JULHO 2000

--------------------------------------------------------------------------



INTRODUÇÃO

==========



O programa trace funciona como um módulo operacional do Microbug, e

reúne as funções de Disassembler e simulador de programas assembler.

Ele implementa os comandos S (simulador de instruções) e T (Disassembler),

além de U e V como auxiliares do comando S.





COMANDOS DO TRACE

=================



COMANDO T: serve para disassemblar trechos de memória. Funciona como os

comandos M e D tendo a seguinte estrutura: T <endereço>. Se não for

digitado o endereço, continua-se a partir da instrução seguinte à última

disassemblada. A tecla K vai disassemblando as instruções dali em diante

e para sair deste comando é só dar <BREAK>. Existem os seguintes comandos

SHIFT:



- SHIFT E/SHIFT S: como nos outros comandos do Microbug.

- SHIFT A: chaveia a impressão ou não dos bytes que compõem a instrução.

- SHIFT 3: chaveia em decimal/hexa a impressão dos bytes da instrução.

Quando for usada a impressão em decimal, em algumas instruções os bytes

sobreporão o código da instrução.

- SHIFT D: chaveia em decimal/hexa a impressão dos bytes dos operandos da

instrução.





COMANDO S: serve para fazer a simulação passo-a-passo de um programa em

Assembler. Seu formato é S <endereço>. Se o endereço não for digitado,

assume-se o último endereço usado no comando S (e não o seguinte a ele).

O comando S disassembla a instrução nesse endereço e mostra, nas duas

últimas linhas da tela, a tela do comando H, onde estão os principais

registradores do Z80 (AF, HL, DE, BC), seus conteúdos em hexa e o valor

binário dos flags. A partir daí existem as seguintes opções:



- Tecla V: mostra, na primeira linha da tela, os seguintes elementos:

* O valor da posição de memória apontada por HL, ou por IX,IY+d, se a

instrução que foi disassemblada fizer referência a IX ou IY.

* O valor de seu SP. É um valor diferente do SP do sistema, e deve

apontar para alguma área da RAM com pelo menos uns 20 bytes, mais os

níveis de stack que você vai precisar. Inicialmente tem valor 6C00.

* O valor de (SP), ou seja, o próximo valor a ser trazido da pilha por

POP ou RET.



- Tecla K: simula a instrução que está sendo mostrada na tela e exibe a

seguinte. Para se fazer a simulação é colocado um break-point na

instrução seguinte, carrega-se nos registradores o valor mostrado na

tela e desvia-se para aquela instrução. Logo depois os registradores

são salvos e é mostrada a próxima instrução (a não ser em instruções

JP, CALL e RET, onde o processo é outro).

As chamadas à ROM (endereços menores que 8192) não são simuladas, e sim

executadas por completos, porque não há como colocar break-points na

ROM. Se você quiser acopanhar a execução de alguma rotina, deve movê-la

para a RAM e realocar seus endereços.



- Tecla +: faz o mesmo que a tecla K, porém a tela é rodada junto com o

valor dos registradores.



- Tecla N: avança para a instrução que está sendo mostrada.



- BREAK: termina o comando.



- Comando U: serve para dar um novo valor ao seu SP (é um N só para o

SP). O formato é U <novo valor>.



- Comando V: é idêntico ao comando H, porém ele exibe também o valor de

(HL) ou (xy+d), do SP e (SP).





CONSIDERAÇÕES:



Nos endereços 711D e 7158 está o valor 7D8D, que é o endereço da rotina

$RCP do Microbug. Se você quiser fazer algum preparo, antes que cada

instrução seja simulada (tal como posicionar o cursor, inicializar

posições, trocar o arquivo de imagens pelo conteúdo de um buffer, passar

o micro para FAST, alterar o valor de IX ou IY ou ainda qualquer outra

coisa), coloque nestas duas posições de memória o endereço de sua rotina,

lembrando de terminá-la com um JP $RCP ou coisa parecida.



Nos endereços 7127 e 715E está o valor 7D7C, que é o endereço da rotina

$ARQ. Aqui se desvia, depois de ter sido simulada, a instrução de seu

programa. Nesta situação, você passaria o micro para SLOW e voltaria o

valor de IX e IY, não sendo necessário reposicionar o cursor nem voltar a

tela que estava sendo mostrada antes.



Os endereços 4021, 407B e 407C são variáveis temporárias dos comandos S e

T, portanto você deve salvá-las, inicializá-las com seu valor desejado e

depois retorná-las, se fizer uso dessas posições em seu programa.



Se você vai fazer uso dos registradores IX ou IY, altere também os

endereços 71CB, 71CC e 71CD, que têm as instruções PUSH IX/POP HL, para

LD HL (seu ix); e os endereços 71D1, 71D2 e 71D3 para LD HL (seu iy).