Вы находитесь на странице: 1из 20

MICROCOMPUTADOR SAP-3

Novos registradores de uso geral (adicionais): D, E, H e L.

Registrador de flags F.

Registrador apontador de pilha (SP, Stack Pointer) de 16 bits.

Instruções de registradores

Sintaxe

Operação

Bytes

MOV reg1,reg2

(reg1) (reg2)

1

MVI reg,byte

(reg) byte

2

onde reg1, reg2, reg = A,B,C,D,E,H ou L.

Mais registradores internos na UCP uso menos frequente da memória programas mais simples, menores e mais rápidos. Os programas do SAP-3 são mais rápidos do que os do SAP-2.

Instruções aritméticas

Dados de 8 bits: resultados sem sinal de 0 a 255, e com sinal de -128 a +127.

Afetam o flag de transporte CY (Carry), que pode ser “vai- um” (na adição) ou “vem-um” (na subtração). A interpretação depende da operação.

CY = CARRY para instruções ADD (SUB = 0) CY = CARRY para instruções SUB

CY = CARRY para instruções ADD (SUB = 0)

CY = CARRY para instruções SUB (SUB = 1)

O resultado tem 8 bits e é armazenado no acumulador. Nas subtrações, um CARRY alto produz um CY baixo, e vice-versa.

Na adição, CY é chamado de “vai-um”. Na subtração, CY é chamado de “vem-um” ou “pede emprestado”. O transporte CY funciona como um bit adicional do acumulador (CY = A 8 ).

Instruções aritméticas

Sintaxe

 

Operação

Bytes

STC

 

(CY) 1

1

CMC

(CY) (CY)

1

ADD reg

(A) (A) + (reg)

1

ADI byte

(A) (A) + byte

2

ADC reg

(A) (A) + (reg) + (CY)

1

ACI byte

(A) (A) + byte + (CY)

2

SUB reg

(A)

(A) – (reg)

1

SUI byte

(A) (A) – byte

2

SBB reg

(A) (A) – (reg) – (CY)

1

SBI byte

(A) (A) – byte – (CY)

2

Adição sem sinal: use o CY. Adição com sinal: despreze o CY. o Exemplos:

(A) = 1111 0001

(E) = 0000 1000

 

ADD E

(CY) = 0

(A) = 1111 1001

(A) = 1111 1111

(L) = 0000 0001

 

ADD L

(CY) = 1

(A) = 0000 0000

A instrução ADC, pelo fato de incluir o transporte CY, torna possível somar números de mais de 8 bits, por etapas.

Quando uma subtração é executada, CY funciona como um flag de "pede emprestado" (borrow) ou "vem-um". O "pede emprestado" final ocorre quando CY = 1. Se não há "vem- um", então CY = 0.

Exemplos: fazer a subtração normal e em complemento de 2:

(A) = 0FH

(CY) = 0

(A) = 0CH

(CY) = 1

(D) = 01H

SUB D

(A) = 0EH

(E) = 12H

SUB E

(A) = FAH

A instrução SBB, pelo fato de incluir o transporte CY, torna possível subtrair números de mais de 8 bits, por etapas.

SBB reg primeiro soma (reg) e (CY), e então subtrai esse resultado do acumulador.

Exemplos: fazer a subtração normal e em complemento de 2:

(A) = FFH

(CY) = 0

(E) = 02H SBB E

(CY) = 1

(A) = FCH

Aplicação: Escrever um programa para somar 700 10 com 900 10 , e colocar o resultado nos registradores H e L.

700 10 = 02BCH

900 10 = 0384H

Instrução

Comentário

MVI

B,02H

;Carrega o byte superior de 700

MVI

C,BCH

;Carrega o byte inferior de 700

MVI

D,03H

;Carrega o byte superior de 900

MVI

E,84H

;Carrega o byte inferior de 900

MOV

A,C

;Copia C em A

ADD

E

;Soma o byte inferior de 900 com A

MOV

L,A

;Salva o byte inferior da soma em L

MOV

A,B

;Coloca o byte superior de 700 em A

ADC

D

;Soma o byte superior de 900 e CY

MOV

H,A

;Salva o byte superior da soma em H

HLT

 

A resposta em HL é 0640H, igual a 1600 10 .

Aplicação: Escrever um programa para subtrair 700 10 de 900 10 , e colocar o resultado nos registradores H e L.

700 10 = 02BCH

900 10 = 0384H

Instrução

Comentário

MVI

A,84H

;Carrega o byte inferior de 900 em A

SUI

BCH

;Subtrai o byte inferior de 700 de A

MOV

L,A

;Salva o byte inferior do resultado

MVI

A,03H

;Coloca o byte superior de 900 em A

SBI

02H

;Subtrai o byte superior de 700 e CY

MOV

H,A

;Salva o byte superior do resultado

HLT

 

Incrementos, decrementos e rotações

Sintaxe

Operação

Bytes

INR reg

(reg) (reg) + 1

1

DCR reg

(reg) (reg) - 1

1

RAL

(A i ) (A i-1 ); (A 0 ) (CY); (CY) (A 7 )

1

RAR

(A i-1 ) (A i ); (A 7 ) (CY); (CY) (A 0 )

1

RLC

(A i ) (A i-1 ); (A 0 ) (A 7 ); (CY) (A 7 )

1

RRC

(A i-1 ) (A i ); (A 7 ) (A 0 ); (CY) (A 0 )

1

As instruções INR e DCR afetam os flags de sinal e de zero (S e Z), mas não afetam o flag de transporte CY.

O flag de transporte CY permanece inalterado mesmo que ocorra um “estouro” no registrador incrementado.

Exemplos:

(B)

= 1111 1111

S

= 1

Z =

0

CY = 0

 

INR B

 

(B)

= 0000 0000

S

= 0

Z =

1

CY = 0

(E)

= 0000 0000

S

= 0

Z =

1

CY = 0

 

DCR E

 

(E)

= 1111 1111

S

= 1

Z =

0

CY = 0

As instruções de rotação agora incluem o flag de transporte. Nas instruções RAL e RAR, CY funciona como uma extensão de A.

Nas instruções RLC e RRC, CY não é uma extensão de A. O acumulador rotaciona seus bits sozinho, para a esquerda (RLC) ou para a direita (RRC). o O conteúdo de CY é perdido. Com uma RLC, CY recebe o MSB. Com uma RRC, CY recebe o LSB.

As instruções de rotação servem para converter dados da forma paralela para a forma serial, e vice-versa.

As instruções de rotação também servem para multiplicar ou dividir por 2 o conteúdo do acumulador.

Com CY = 0, RAL multiplica por 2 e RAR divide por 2.

Exemplos: CY = 0

(A) = 1110 1000

 

RAL

CY = 1

(A) = 1101 0000

CY = 0

(A) = 1110 1000

 

RAR

CY = 0

(A) = 0111 0100

RLC e RRC não garantem produzir um resultado correto logo na primeira execução.

Instruções lógicas

Sintaxe

 

Operação

Bytes

ANA reg

(A) (A) AND (reg)

1

ANI byte

(A) (A) AND byte

2

ORA reg

(A) (A) OR (reg)

1

ORI byte

(A) (A) OR byte

2

XRA reg

(A) (A) XOR (reg)

1

XRI byte

(A) (A) XOR byte

2

CMP reg

Z

= 1 se (A) = (reg);

1

Z

= 0 se (A) (reg)

CPI byte

Z

= 1 se (A) = byte;

2

Z = 0 se (A) byte

Para a execução de CMP reg, (A) é copiado para o registrador TMP. Então a ULA faz (TMP) – (reg), afetando o flag Z.

Por isso, se (A) = (reg), então Z=1, e se (A) (reg), então Z=0. Como é usado o registrador TMP, a instrução CMP não afeta o conteúdo do acumulador ou de reg.

A instrução CMP, usada com uma instrução JZ, permite controlar laços de uma nova maneira (com o contador crescendo).

Rótulo

Instrução

Comentário

 

MVI

E,00H

;Inicializar o contador

LOOP:

   
 

INR

E

;Incrementar o contador

 

MOV

A,E

;Copiar E para A

 

CPI

FFH

;Comparar A com 255

 

JNZ

LOOP

;Repetir se A não for 255

Instruções de desvio de programa

Sintaxe

 

Operação

Bytes

JMP endereço

 

(PC) endereço

3

JM endereço

S

= 1: (PC) endereço;

3

S

= 0: (PC) (PC) + 1

JP endereço

S

= 0: (PC) endereço;

3

S

= 1: (PC) (PC) + 1

JZ endereço

Z

= 1: (PC) endereço;

3

Z

= 0: (PC) (PC) + 1

JNZ endereço

Z

= 0: (PC) endereço;

3

Z

= 1: (PC) (PC) + 1

JC endereço

CY = 1: (PC) endereço; CY = 0: (PC) (PC) + 1

3

JNC endereço

CY = 0: (PC) endereço; CY = 1: (PC) (PC) + 1

3

JPE endereço

P

= 1: (PC) endereço;

3

P

= 0: (PC) (PC) + 1

JPO endereço

P

= 0: (PC) endereço;

3

P

= 1: (PC) (PC) + 1

JPE e JPO desviam com base no flag de paridade P:

o

P=1: o resultado da ULA tem um número par de 1’s.

o

P=0: o resultado da ULA tem um número ímpar de 1’s.

Instruções de registradores extendidos

Certas instruções enxergam os registradores da UCP encadeados aos pares, para assim processar dados de 16 bits.

Essas instruções tratam o par de registradores como um único registrador, tendo o nome do primeiro registrador do par.

A associação dos registradores em pares é feita sempre assim:

B

C

D

E

H

L

Sintaxe

 

Operação

Bytes

LXI

B,word

(B)

byte superior;

3

(C)

byte inferior

LXI

D,word

(D)

byte superior;

3

(E)

byte inferior

LXI

H,word

(H)

byte superior;

3

(L)

byte inferior

DAD

B

(HL) (HL) + (BC)

1

DAD

D

(HL) (HL) + (DE)

1

DAD

H

(HL) (HL) + (HL)

1

INX

B

(BC) (BC) + 1

1

INX

D

(DE) (DE) + 1

1

INX

H

(HL) (HL) + 1

1

DCX

B

(BC) (BC) - 1

1

DCX

D

(DE) (DE) - 1

1

DCX

H

(HL) (HL) - 1

1

DAD afeta o flag de transporte CY, se houver um transporte do par HL de registradores (resultado da soma com mais de 16 bits).

DAD H duplica o valor de HL.

INX e DCX não têm efeito sobre os flags.

Instruções de endereçamento indireto

São instruções que usam o conteúdo do par HL como o endereço de um dado na memória, isto é, (HL) é enviado para o REM, para que seja feita uma leitura ou escrita na memória.

Para essas instruções, o par HL aponta para a posição de memória onde um dado está armazenado, ou onde um dado deve ser armazenado. HL é então um apontador de dados.

Essas instruções usam o modo de endereçamento indireto, pois o endereço é uma variável, que pode mudar no decorrer do programa. Podem-se fazer cálculos com os endereços.

Por outro lado, no endereçamento direto, os endereços são constantes (por exemplo, LDA 5000H ou STA 2000H).

Nesta tabela, M = (HL).

Sintaxe

 

Operação

Bytes

MOV reg,M

 

(reg) ((HL))

1

MOV M,reg

 

((HL)) (reg)

1

MVI M,byte

 

((HL)) byte

2

ADD M

(A) (A) + ((HL))

1

ADC M

(A) (A) + ((HL)) + (CY)

1

SUB M

(A) (A) - ((HL))

1

SBB M

(A) (A) - ((HL)) - (CY)

1

INR M

((HL)) ((HL)) + 1

1

DCR M

((HL)) ((HL)) - 1

1

ANA M

(A)

(A) AND ((HL))

1

ORA M

(A) (A) OR ((HL))

1

XRA M

(A)

(A) XOR ((HL))

1

CMP M

Z

= 1 se (A) = ((HL));

1

Z

= 0 se (A) ((HL))

Exemplo de programa em assembly

Programa para copiar 256 bytes dos endereços de memória 2000H a 20FFH para a faixa de endereços 3000H a 30FFH.

Rótulo

Instrução

Comentário

 

LXI

H,1FFFH

;Inicializar apontador HL

LOOP:

INX

H

;Incrementar HL

 

MOV

B,M

;Ler o byte de (HL)

 

MOV

A,H

;Carregar H (20H) em A

 

ADI

10H

;Adicionar para chegar a 30H

 

MOV

H,A

;Devolver para H

 

MOV

M,B

;Escrever o byte no novo endr

 

SUI

10H

;Subtrair para voltar a 20H

 

MOV

H,A

;Restaurar H para 20H

 

MOV

A,L

;Copiar para A para comparar

 

CPI

FFH

;Comparar A com FFH

 

JNZ

LOOP

;Se não for, voltar para LOOP

 

HLT

 

Instruções de manipulação de pilha

A pilha é uma área da memória, definida por instruções, onde os dados são escritos e lidos de forma serializada, isto é, um após o outro em sequência.

No SAP-3, o programador decide onde iniciar a área de pilha na memória e que tamanho ela vai ter.

Uma pilha é usada para:

o Guardar sucessivos endereços de retorno de sub- rotinas. o Guardar dados de uso geral.

Um registrador de 16 bits da UCP, chamado de SP (Stack Pointer ou Apontador de Pilha), tem a função de indicar a posição de memória na pilha que deve ser acessada (lida ou escrita) pelas instruções de pilha.

O apontador de pilha é inicializado com uma instrução de carga imediata: LXI SP, word

Instruções de empilhamento

Os conteúdos do acumulador e do registrador de flags são denominados conjuntamente de PSW (Program Status Word ou Palavra de Estado de Programa).

PSW = (A)(F)

Quando se vai chamar uma sub-rotina, pode ser necessário guardar antes a PSW, para que o programa principal possa prosseguir de forma correta depois que a sub-rotina retornar.

Pode ser necessário guardar também os conteúdos dos demais registradores, antes do início da sub-rotina. Isso preserva todo o estado da CPU antes da execução da sub- rotina.

A instrução de empilhamento é PUSH, que guarda dados na pilha. Há quatro instruções PUSH, que enxergam os registradores aos pares (‘B’ = BC, ‘D’ = DE, ‘H’ = HL).

Sintaxe

Operação

Bytes

PUSH B

(SP) (SP) – 1; ((SP)) (B); (SP) (SP) – 1; ((SP)) (C)

1

PUSH D

(SP) (SP) – 1; ((SP)) (D); (SP) (SP) – 1; ((SP)) (E)

1

PUSH H

(SP) (SP) – 1; ((SP)) (H); (SP) (SP) – 1; ((SP)) (L)

1

PUSH PSW

(SP) (SP) – 1; ((SP)) (A); (SP) (SP) – 1; ((SP)) (F)

1

As instruções PUSH empilham sempre palavras de 16 bits, primeiro o byte superior e depois o byte inferior.

Exemplos de instruções PUSH

(BC) = 5612H

PUSH B

(SP) = 2100H

1. SP é decrementado para 20FFH; 2. O byte superior 56H é guardado na memória, no endereço 20FFH ; 3. SP é decrementado para 20FEH; 4. O byte inferior 12H é guardado na memória, no endereço 20FEH.

(SP) = 2100H,

(AF) = 1234H,

(DE) = 5678H,

PUSH PSW PUSH D PUSH H

(HL) = 9A25H

 

dados

endereços

SP

25H

20FAH

9AH

20FBH

78H

20FCH

56H

20FDH

34H

20FEH

12H

20FFH

A pilha cresce “para cima” a partir do endereço (SP–1), no sentido decrescente dos endereços da memória.

SP sempre “aponta” para o último dado empilhado.

Instruções de desempilhamento

Fazem o inverso das instruções PUSH, restaurando os conteúdos dos registradores empilhados.

Sintaxe

 

Operação

Bytes

POP B

(C)

((SP)); (SP) (SP) + 1;

1

(B)

((SP)); (SP) (SP) + 1

POP D

(E)

((SP)); (SP) (SP) + 1;

1

(D)

((SP)); (SP) (SP) + 1

POP H

(L)

((SP)); (SP) (SP) + 1;

1

(H)

((SP)); (SP) (SP) + 1

POP PSW

(F)

((SP)); (SP) (SP) + 1;

1

(A)

((SP)); (SP) (SP) + 1

As instruções POP também enxergam os registradores aos pares, e desempilham 2 bytes de cada vez.

A ordem do desempilhamento é inversa à ordem do empilhamento. A pilha opera no modo LIFO (Last In, First Out): o último dado que entra na pilha é o primeiro que sai.

Exemplo:

 

dados

endereços

SP

25H

20FAH

9AH

20FBH

78H

20FCH

56H

20FDH

34H

20FEH

12H

20FFH

POP B :

(C) 25H;

(SP) 20FBH;

(B) 9AH;

(SP) 20FCH. (BC) = 9A25H

POP PSW :

(AF) = 5678H

POP H:

(HL) = 1234H

(SP) = 2100H

17

Chamadas e retornos de sub-rotinas

Endereço

 

Instrução

2000H

LXI

SP,FFFFH

2001H

 

2002H

 

2003H

CALL 8050H

2004H

 

2005H

 

2006H

MVI

A,0EH

20FFH

HLT

8050H

 

8059H

RET

CALL provoca o empilhamento do endereço da próxima instrução (endereço de retorno). Então o PC é carregado com 8050H e a execução vai para a sub-rotina.

 

dados

endereços

….

….

SP

06H

FFFDH

20H

FFFEH

 

FFFFH

RET desempilha o endereço de retorno e o devolve ao PC. SP volta a conter FFFFH.

SP precisa ser inicializado pelo programador com o limite superior da pilha (seu maior endereço). É preciso ter cuidado para que a pilha não invada a área de programa ou outra área de dados. Ela pode ficar no final da memória.

Chamadas condicionais de sub-rotinas

 

Sintaxe

 

Operação

Bytes

CNZ endereço

Z

= 0: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço.

3

Z

= 1: (PC) (PC) + 1

CZ

endereço

Z

= 1: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço.

3

 

Z

= 0: (PC) (PC) + 1

CNC endereço

CY = 0: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço. CY = 1: (PC) (PC) + 1

3

CC

endereço

CY = 1: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço. CY = 0: (PC) (PC) + 1

3

CP

endereço

S

= 0: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço.

3

 

S

= 1: (PC) (PC) + 1

CM

endereço

S

= 1: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço.

3

 

S

= 0: (PC) (PC) + 1

CPE endereço

P

= 1: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço.

3

P

= 0: (PC) (PC) + 1

CPO endereço

P

= 0: (SP) (SP)-1; ((SP)) (PC H ); (SP) (SP)-1; ((SP)) (PC L ); (PC) endereço.

3

P

= 1: (PC) (PC) + 1

Retornos condicionais de sub-rotinas

Sintaxe

 

Operação

Bytes

RNZ endereço

Z

= 0: (PC) ((SP+1))((SP));

3

Z

= 1: (PC) (PC) + 1

RZ endereço

Z

= 1: (PC) ((SP+1))((SP));

3

Z

= 0: (PC) (PC) + 1

RNC endereço

CY = 0: (PC) ((SP+1))((SP)); CY = 1: (PC) (PC) + 1

3

RC endereço

CY = 1: (PC) ((SP+1))((SP)); CY = 0: (PC) (PC) + 1

3

RP endereço

S

= 0: (PC) ((SP+1))((SP));

3

S

= 1: (PC) (PC) + 1

RM endereço

S

= 1: (PC) ((SP+1))((SP));

3

S

= 0: (PC) (PC) + 1

RPE endereço

P

= 1: (PC) ((SP+1))((SP));

3

P

= 0: (PC) (PC) + 1

RPO endereço

P

= 0: (PC) ((SP+1))((SP));

3

P

= 1: (PC) (PC) + 1

Durante a execução das instruções CALL e RET, as operações com a pilha são realizadas automaticamente pelo computador.