Instrucoes Aritmeticas e Logicas
No capitulo anterior apresentaram-se as instruções elementares do microprocessador Z80 que versavam, essencialmente, sobre a manipulação da informação do microprocessador para a memória, da memória para o microprocessador e dentro da própria CPU (transferência entre registos).
Esta
informação, que até este momento se circulava de uns elementos para outros
do sistema, vai ser transformada e testada, em suma, vai ser processada pelo
microprocessador. Um grupo de instruções que realiza estas tarefas são as
instruções aritméticas e lógicas.
As
instruções aritméticas e lógicas realizam operações muito simples sobre o
acumulador e uma determinada fonte que, por exemplo, pode ser um dos registos de
uso geral. Em quase todas elas o acumulador é uma das fontes e o destino da
operação. As instruções que incrementam e decrementam registos representam
a excepção a esta regra.
O
resultado destas operações, como veremos a seguir, vai modificar
O
registo de flags. Por exemplo, se numa operação de subtracção o resultado
for zero a flag Z tomará o valor «1».
INSTRUÇÕES DE 8 BITS
ADD,
Adição de Dois Registos
Esta
instrução é formada por um único byte. O conteúdo do registo especificado
pelos últimos três bits do código de instrução é adicionado ao conteúdo
do acumulador. O resultado da operação mantém-se no acumulador.
Vejamos
alguns exemplos de adições.
Adicionar
o conteúdo dos registos A e B, contendo A os valores 0AH, FFH, 0FH e B os
valores 03H, 0l H e 0l H.
Neste
exemplo, todas as flags com significado são colocadas a 0, o que é
perfeitamente compreensível pela análise do resultado da operação. Não ha
transporte do primeiro nibble para o segundo (H=0), não há transporte de byte
(C =0), não há overflow (P=0), o
resultado é diferente de zero (Z¹0) e positivo (S=0). O
significado da flag N sera abordado posteriormente.
A
flag Z=1 revela que os oito bits do acumulador têm o valor 0 mas isto não
significa por si só que o resultado da operação seja nulo. Com efeito, a flag
do carry (C) é colocada a 1 indicando 0 transporte de I para outro byte mais
significativo. Repare-se que a flag H (half carry) também é colocada a 1 pois
existe um transporte do primeiro nibble para o segundo nibble.
A
flag de zero é accionada (Z= 1) pois, de facto 1 o acumulador no final da operação
contém apenas zeros.
Vejamos,
finalmente, o ultimo exemplo, a adição dos valores hexadecimais 0FH e 01H.
Neste
exemplo o único caso a assinalar é o transporte existente do primeiro nibble
para o segundo nibble, o qual provoca a colocação da flag H a 1.
ADD, Adição de Um Byte de
Dados ao Acumulador
Esta
instrução é formada por dois bytes. 0 primeiro byte representa 0 código do
operação, 0 segundo byte contém a palavra de dados que só pretende adicionar
ao conteúdo do acumulador:
Convém
acentuar que o byte de dados é o byte que imediatamente se segue ao byte do código
da instrução.
ADD, Adição de Um Byte de Dados da Memória só Acumulador
As
instruções que permitem adicionar um byte de dados na memória ao conteúdo do
acumulador podem-se dividir em dois conjuntos1 consoante o tipo de endereçamento
da célula de memória.
O
endereçamento pode ser indirecto ou indexado. No primeiro caso, par
HL contém o endereço da posição de memória que contém a palavra de dados.
No segundo caso, o endereço é obtido através da adição de um byte da instrução
(o terceiro) ao conteúdo de um dos registos de (índice, IX ou IY.
No modo indirecto temos uma instrução constituída
por único byte. No modo indexado a instrução é formada por três bytes:
Estas
três instruções de adição de bytes da memória com 0 conteúdo do
acumulador vão provocar mudanças no registo de flags idênticas &S
apresentadas para as instruções de adição anteriores. Alias, estas instruções
diferem apenas no modo como 0 segundo operando (o primeiro esta no acumulador)
é encontrado. Os exemplos apresentados continuam, obviamente, a ser verdadeiros
no caso destas instruções.
Na
tabela 13 estão representados Os códigos hexadecimais das instruções de adição
sem transporte (ADD).
Tabela
13
ADC,
Adição com Carry
A
adição com carry (ADC) é formada por um grupo de cinco instruções
equivalentes as cinco instruções de adição (ADD) apresentadas anteriormente.
A adição com carry difere no facto de se adicionar 0 valor da flag de carry ©
ao resultado da adição do conteúdo do acumulador com 0 outro operando.
Identicamente 0 resultado é colocado no acumulador:
Adição
com carry ADC A, S (A ¬A + S + CY) em que
A
≡ acumulador
S
≡ segundo operando
CY
≡ valor da flag de carry (C).
Os
códigos binários das instruções de adição com transporte (add with carry)
podem-se obter, facilmente1 a partir dos códigos das instruções de adição
simples (ADD). Para isso basta substituir nos códigos anteriores Os três bits
dentro de um rectângulo tracejado 0 0 0 pelos três bits 0 0 1. Obtém-se,
assim, cinco instruções de adição com transporte correspondendo aos diversos
modos de endereçamento do segundo operando, uma vez que 0 primeiro operando
reside sempre no acumulador.
Por
exemplo, a instrução de adição, com transporte, do acumulador com um byte de
dados que segue imediatamente 0 código de instrução, tem a seguinte forma:
Este
grupo de instruções afecta 0 byte de flags do mesmo modo que as instruções
ADD.
Apresentam-se
em seguida dois exemplos de adição com carry.
No
primeiro exemplo, o acumulador tem o valor 0AH, o registo C tem o valor 65H e a
flag de carry o valor 1.
O
valor da flag de carry, C= 1, simula uma possível situação desta flag em
resposta ao resultado de uma operação anterior.
registo
de flags é actualizado segundo o resultado da operação ADC. Todas as flags são
colocadas a zero (reset) com excepção da flag H que indica um transporte do
primeiro nibble para o segundo nibble.
No
segundo exemplo, o acumulador contam o numero hexadecimal F C H, o registo E
contam o valor 04 H e a flag de carry o valor 0:
O
valor da flag de carry, C=0, simula uma possível situação desta flag em
resposta ao resultado de uma operação anterior.
valor
final do acumulador é zero, logo, a flag de zero é colocada (set) a 1. Existe
um transporte do primeiro nibble para o segundo, pelo que a flag H é colocada a
1. Finalmente, existe um transporte de byte que provoca a colocação da flag de
carry a 1 (C= 1).
Na
tabela 14 estão representados os códigos hexadecimais das instruções de adição
com transporte (add with carry), ADC.
Tabela
14
SUB,
subtracção de Um Operando ao Conteúdo do Acumulador
A
instrução SUB subtrai ao conteúdo do acumulador um operando armazenado num
registo, numa posição de memória ou num byte da própria instrução.
Os
códigos da instrução SUB podem-se obter a partir dos códigos da instrução
ADD, tal como sucedia para a instrução ADC. Com efeito, basta substituir nos códigos
da instrução ADD os três bits dentro do rectângulo tracejado 0 0 0 pelos três
bits 0 1 0. Obtém-se, assim, cinco instruções de subtracção correspondentes
aos diferentes tipos de endereçamento possíveis para o operando que se subtrai
ao conteúdo do acumulador. Tal como nas instruções antecedentes, o resultado
da operação é armazenado no acumulador: A¬A
- S, em que A representa o acumulador ee S o segundo operando.
Vejamos
dois exemplos de subtracção do conteúdo do acumulador a partir de um operando
armazenado no registo L.
A
FLAG N com o valor 1 indica que a operação efectuada foi uma subtracção. O
resultado das flags S, Z, PN e C é evidente.
O
bit numero 7 do acumulador tem o valor 1 logo, a flag de sinal 6
activada.
A flag C= 1 indica um transporte no ultimo bit (borrow). Re-
pare-se
que, apesar deste transporte, a flag de overflow não foi activada. Como o último
bit do acumulador contém o valor 1 o resultado tem de ser entendido na forma de
complemento para dois. Então, calculando este complemento, obtemos o resultado
correcto:
10
H-30 H=-20 H
Se
considerarmos a subtracção 7FH - ADH, existem duas possibilidades de
interpretação do resultado armazenado no acumulador:
A-D2.
Uma das hipóteses é considerar que AD representa um número negativo (em
complemento para dois = -53 H) e o resultado será D2 H, ocorrendo
necessariamente overflow [7F H-(-53H)=D2 H]. A outra hipótese é considerar que
na diferença efectuada os números não têm sinal e 7FH - ADH = -2E H. o
complemento para dois de 2E H é D2 H, tal como se obteve. Esta ultima hipótese
é um pouco paradoxal uma vez que consideramos A partida números sem sinal para
no fim obtermos um resultado com sinal (-). As flags de interesse apresentam
os seguintes valores: 5=1, Z=0, P/V=1, C= 1. PW = 1 assinala o overflow da
primeira hipótese, enquanto C= 1 assinala a incongruência da segunda.
Tabela
15
SBC,
Subtracção com Carry
A
instrução SBC é idêntica á instrução SUB. A diferença reside no facto de
se subtrair ao conteúdo do acumulador, além do byte subtractor, o valor do
byte da flag de carry (C) . Mais uma vez o resultado da operação é colocado
no acumulador:
Subtracção
com carry - SBC A,S (A¬A
- S - Cy) em que
A
≡ acumulador
S
≡ segundo operando
Cy
≡ valor da flag
de carry (C)
Os
códigos hexadecimais das cinco operações SBC obtém-se por substituição nas
instruções de ADD dos três bits dentro do rectângulo tracejado 0 0 0 pelos
três bits 0 11 . As instruções SBC obtidas através desta substituição
cobrem os diferentes modos de endereçamento do operando a subtrair ao
acumulador: modo directo, modo indirecto, modo indexado (duas instruções) e
modo imediato.
Apresentam-se
em seguida dois exemplos de subtracção com carry em que são intervenientes o
acumulador e um byte da própria instrução SBC (endereçamento imediato). No
primeiro exemplo a flag de carry tem o valor 0, enquanto no segundo exemplo a
flag tem o valor 1.
0 conteúdo do acumulador e do byte n foram
considerados arbitrariamente.
0 registo de flags indica que o resultado é
negativo, apresentando-se na forma de complemento para dois (S=11). A flag C
indica que o diminuidor é superior ao diminuendo, daí resulta que o resultado
da subtracção terá de ser, obviamente, negativo.
Para o segundo caso escolheu-se para conteúdo do
acumulador o valor OB H e para o byte n OA H. Neste exemplo, antes de a operação
SBC ser efectuada, a flag de carry tem o valor 1.
OPERAÇÃO A EFECTUAR: SBC A, n (A¬A-n-Cy)
CÓDIGO DE OPERAÇÃO: DEH, n
Neste exemplo o resultado final é nulo. Assim, a
flag de zero é activada e toma o valor 1 . N=11 indica que a operação
efectuada foi uma subtracção.
AND, Operação Lógica E entre o Conteúdo do
Acumulador e Um Operando
A instrução AND efectua o produto lógico entre o
conteúdo do acumulador e um segundo operando que se encontra armazenado num
registo, numa célula de memória ou que faz parte do próprio código de instrução.
Na figura 14a) encontra-se representada a tabela de verdade do operador lógico
E.
Assim como sucedia para as instruções aritméticas
anteriormente focadas, existem cinco instruções AND de acordo com os
diferentes modos de endereçamento do segundo operando (no modo directo existem
sete códigos correspondendo aos sete registos da CPU).
Os códigos destas instruções obtêm-se a partir
dos códigos das instruções ADD substituindo os bits dentro do rectângulo
tracejado 0 0 0 pelos três bits 1 0 0 .
As instruções AND afectam o byte de flags do
seguinte modo:
↨-flag colocada consoante o resultado da operação
P - flag colocada consoante a paridade do resultado
0 - flag de reset
X - valor ignorado
Para este grupo de instruções as flags de maior
importância são a flag S, a flag Z e a flag P. A flag S toma o valor 1 se o
oitavo bit do acumulador, depois de efectuada a operação, tiver o valor 1. Se
o resultado do E lógico for nulo, e o acumulador contiver apenas zeros, a flag
Z tomará o valor 1. A fia9 P tomará o valor 1 se o resultado da operação for
par, se for ímpar a flag terá o valor 0.
Vejamos dois exemplos da instrução AND entre o
conteúdo do acumulador e o registo B. 0 acumulador contém o operando ACH nos
dois exemplos, enquanto o registo B contém ACH no primeiro caso e 53 H no
segundo caso.
OPERAÇÃO A EFECTUAR: AND A, B (A<--AAB)
CÓDIGO DE OPERAÇÃO: AO H
Note-se que a flag de sinal toma o valor 1 porque o
bit 7 (oitavo) do resultado tem o valor 1. Por sua vez, a flag P é colocada em
1 devido à paridade par do resultado.
OPERAÇÃO A EFECTUAR: AND A, B (A<-AAB)
CÓDIGO
DE OPERAÇÃO: AO H
Um resultado nulo no acumulador provoca o set da flag
de zero.
Na tabela 17 encontram-se representados os códigos
hexadecimais das instruções AND.
OR, Operação Lógica OU
entre o Conteúdo do Acumulador e Um Operando
Na
figura 14b) está representada a tabela de verdade do operador lógico OU.
Os
códigos desta operação podem-se obter a partir dos códigos da instrução
AM. Os três bits situados dentro do rectângulo 0 0 0 são substituídos pelos
três bits 1 1 0 obtendo-se, assim, os códigos desejados correspondentes aos
diversos modos de endereçamento.
As
instruções OR afectam o byte de flags do mesmo modo que as instruções AND.
As
flags de maior importância continuam a ser a flag S, indicadora de que o bit
mais significativo do resultado é 1, a flag Z, indicadora de que o resultado da
operação colocou todos os bits do acumulador a 0 e a flag P colocada a 1 se o
resultado da operação tiver paridade par.
Apresenta-se
a seguir um exemplo da operação lógica OU entre os conteúdos dos registos A
e L:
OPERAÇÃO
A EFECTUAR: OR A,1---(A<--AVL)
CÓDIGO
DE OPERAÇÃO: B5 H
Repare-se no valor da flag P indicando paridade ímpar.
Com efeito, o número de uns existentes no resultado é igual a cinco.
Na tabela 18 estão representados os códigos
hexadecimais das instruções OR.
XOR, Operação Lógica OU EXCLUSIVO entre o Conteúdo
do Acumulador e Um Operando
Na
figura 14c) encontra-se representada a tabela de verdade do operador lógico OU
EXCLUSIVO.
Os
códigos das instruções XOR podem-se obter, novamente, a partir dos códigos
das instruções AM. De novo os três bits dentro do rectângulo tracejado 0 0 0
devem ser substituídos pelos bits 1 0 1 .
A
instrução XOR, quando aplicada sobre o próprio acumulador, é um dos
processos de colocar este registo só com zeros. Analisemos este exemplo.
OPERAÇÃO
A EFECTUAR: XOR A,A (A<--AG)A)
CÓDIGO
DE OPERAÇÃO: AFI-1
A
flag de zero é accionada pois todos os bits do acumulador são colocados a 0.
Notar também que um resultado nulo apresenta paridade par. 0 byte de flags
nesta instrução é afectado de um modo semelhante ao das instruções AND e
OR.
Representam-se
na tabela 19 os códigos hexadecimais das instruções XOR.
CP,
Compara Um Operando com o Conteúdo do Acumulador
A
instrução CP efectua a subtracção de um operando ao conteúdo do acumulador.
Ao contrário da instrução SUB (ou SBC), a instrução CP não altera o conteúdo
do acumulador, servindo este apenas como fonte. 0 operando subtractor pode-se
encontrar num registo, modo de endereçamento directo, numa célula de memória,
modo indirecto e indexado, ou pode-se ainda encontrar no próprio código da
instrução CP, modo de endereçamento imediato.
0
resultado da operação é obtido através da consulta do byte de flags:
A>S→Z=0
e Cy= 0
A=S→Z=1
e Cy=O
A<S→Z=0
e Cy= 1
em
que A representa o conteúdo do acumulador, S o operando a comparar, Z e Cy as
flags de zero e carry, respectivamente.
Mais
uma vez os códigos das instruções CP obtêm-se a partir dos códigos das
instruções ADD, substituindo os três bits 000 pelos bits 1 1 1 .
Vejamos
um exemplo de aplicação da instrução CP em que o acumulador contém o valor
1 F H e a célula de memória 1900 H o valor 18 H.
Trata-se
de uma operação em que o modo de endereçamento, do operando a comparar com o
conteúdo do acumulador, é indirecto. Então, o par de registos HL, deve conter
o endereço da posição de memória, 1900 H.
OPERAÇÃO
A EFECTUAR: CP A, (HL) (A-(HL)
CÓDIGO
DE OPERAÇÃO: BE H
Z=O
e Cy=O→ A>S
As
flags não abordadas, com excepção da flag N, que é sempre igual a 1, também
são afectadas pelo resultado da operação de comparação. No entanto, estas
flags não são determinantes para averiguar a relação de grandeza entre os
dois operandos.
Na
tabela 20 encontram-se os códigos hexadecimais das instruções CP.
INC,
Incrementação de Um- Registo ou de Urna Posição de Memória
Esta
instrução, ao contrário das anteriores, não utiliza o acumulador como fonte
e resultado de todas as operações. Apenas o registo seleccionado (no qual se
inclui o acumulador) ou a posição de memória endereçada são incrementados
de uma unidade.
Em
qualquer dos casos o byte de flags é afectado do seguinte modo:
↨ - flag afectada consoante o resultado da
operação;
X - flag desconhecida;
V - flag indicadora de overflow (=1);
0 - flag de reset;
o - flag não afectada.
Analisemos uma por uma as instruções INC.
1 - INC r, incremento de um registo de uso geral.
Esta instrução é formada por um único byte e
permite o incremento de um dos sete registos de uso geral, incluindo o
acumulador: A, B, C, D, E, H e L.
0 código de operação é o seguinte:
Vejamos
dois exemplos da instrução INC. No primeiro o registo B contém o valor
hexadecimal FF H. No segundo o registo H contém o valor 7F H.
OPERAÇÃO
A EFECTUAR: INC B (B<B+1)
CÓDIGO
DE OPERAÇÃO: 04 H
A flag de zero é accionada, pois o resultado da
operação coloca todos os bits do registo a 0. Repare-se que para esta instrução
a flag de carry não altera o seu valor (●).
OPERAÇÃO A EFECTUAR: INC H (H<-H+1)
CÓDIGO DE OPERAÇÃO: 24 H
A FLAG S é colocada em 1 porque o bit nº 7 tem o
valor 1. Por sua vez, a flag de overflow é accionada, visto que houve um
transporte do bit nº 6 para o bit nº 7. Este bit antes da operação tinha o
valor 0. Foi a mudança para 1 que fez a flag P/V tomar o valor 1.
Na tabela 21 apresentam-se os códigos das instruções
de incremento de registos (INC r).
2
- INC (HL): incremento de uma posição dee memória (modo indirecto).
A
instrução (HL) é formada por um único byte e realiza o incremento de uma célula
de memória cujo endereço se encontra no par HL. Obviamente, a célula de memória
diz respeito à memória RAM. 0 código de instrução tem a seguinte configuração:
Incremente-se
a posição de memória 1910 H que contém o valor hexadecimal AO H:
OPERAÇÃO
A EFECTUAR: INC (HL) ((HL)<-(HL)+1)
CÓDIGO
DA OPERAÇÃO: 34 H
REGISTO
HL: 1910 H
0
registo de flags é afectado da mesma forma que na instrução de incremento de
registos (INC r).
3
- INC (Ix+d), INC (Iy+d): incremento de uma posição de memória
(modo indexado)
São duas as instruções INC que utilizam o modo de
endereçamento inclexado de uma célula de memória. Estas duas instruções
correspondem aos dois registos de índice, IX e IY, existentes no
microprocessador Z80.
Estas instruções são constituídas por três bytes,
armazenando o terceiro byte o valor d, que se deve adicionar a um dos registos
de índice a fim de se obter o endereço da célula de memória que se pretende
incrementar.
Por exemplo, suponhamos que queremos incrementar a célula
de memória cujo endereço é 1905 H, o registo IX contém o valor 1900 H e o
valor de d será, naturalmente, 05 H. Arbitrariamente, escolhe-se para conteúdo
da célula 1905 H o valor FF H:
OPERAÇÃO A EFECTUAR: INC (IX+d) ((IX+d)<-(IX+d)+1)
CODIGO DA OPERAÇÃO: DD H, 34 H, 05 H.
REGISTO IX: 1900 H
Como se pode verificar, o registo de flags foi
modificado do mesmo modo que para as instruções INC r. A flag Z toma o valor
«1» porque a célula de memória no fim da operação ficou inteiramente
preenchida com zeros.
DEC: Decrementação de Um Registo ou de Uma Posição
de Memória
As
instruções DEC são formalmente idênticas às instruções INC. Decrementam
os sete registos da CPU (A, B, C, D, E, H e L) e permitem a decrementação de
uma célula de memória RAM. Esta célula, tal como sucedia nas instruções INC,
pode ser endereçada por intermédio do par de registos HL ou por via dos
registos de índice IX e IY. Neste último caso é necessário especificar um
valor d que o microprocessador adiciona a um dos registos de índice,
constituindo o resultado final o endereço da posição de memória.
Os
códigos binários das instruções DEC obtêm-se a partir dos códigos das
instruções INC. Para isso basta substituir nos códigos das instruções INC
os três bits dentro de um rectângulo tracejado 1 0 0 pelos três bits.
Na
tabela 22 encontram-se representados os códigos hexadecimais das instruções
DEC.
Como
exemplo, decremente-se o registo A que contém, previamente, o valor 00 H. 0
resultado será negativo e igual a -01 H.
OPERAÇÃO A EFECTUAR: DEC A (A<--A-1)
CÓDIGO DE OPERAÇÃO: 3D H
Sendo o resultado negativo (-01) virá em notação
de complemento para dois. É pois necessário complementá-lo novamente para
dois de modo a obtermos o verdadeiro valor do byte resultante. 0 oitavo bit do
registo A colocado a “1” é
indicador de que o resultado é negativo, ao mesmo tempo que a flag de sinal é
colocada igualmente a “1” (número negativo). A flag N com o valor “1”
indica apenas que a operação efectuada foi uma subtracção (subtracção de
uma unidade a um registo).
INSTRUÇÕES ARITMÉTICAS DE 16 BITS
As instruções aritméticas que temos vindo a
abordar realizam operações com registos de oito bits ou com posições de memória
também de oito bits. o microprocessador Z80 também permite a efectivação de
operações aritméticas com 16 bits, isto é, os registos directamente
envolvidos nestas operações são registos de 16 bits (IX, IY e SP) ou pares de
registos de 8 bits (BC, DE, HL).Evidentemente que para estas operações o
destino do resultado já não é o acumulador (registo de 8 bits) mas sim os
registos IX, IY ou o par HL.
1) ADD: adição de dois pares de registos
São três as instruções de ADD em conformidade com
os três destinos que o resultado da operação pode ter, par HL, registo IX e
IY:
0 registo de flags não é afectado do mesmo modo que
no caso das instruções de 8 bits. Apenas duas flags são afectadas: a flag N
que é sempre colocada a 0 (reset) e a flag C colocada de acordo com o resultado
da operação. Sempre que há um transporte do byte de maior ordem (2º byte)
para um hipotético terceiro byte a flag de carry é colocada com o valor 1.
Como exemplo, adicione-se ao par HL que contém o
valor FFFC H, o conteúdo do par BC, 0004 H.
OPERAÇÃO A EFECTUAR: ADD HL, BC
(HL<--HL+BC)
0 único bit com significado do registo de flag é o
correspondente à flag de carry. Neste exemplo, devido ao transporte do bit mais
significativo (oitavo bit do segundo byte), a flag de transporte é colocada no
nível 1.
Na tabela 23 encontram-se representados os códigos
hexadecimais das instruções ADD de 16 bits.
2) ADC: adição com carry de dois pares de registos
A instrução ADC tem apenas um par de registos como
destino da operação: o par HL. É uma instrução de dois bytes, contendo o último
byte a indicação do par de registos (BC, DE, HL, SP) que é adicionado ao par
HL e à flag de carry
A flag de sinal S toma o valor 1 sempre que exista um
bit com o valor 1 na posição mais significativa do resultado, isto é, o bit número
15 (ver fig. 15). A flag Z apresenta o valor 1 se o resultado da operação
preencher os 16 bits do par HL totalmente com zeros. Quanto à flag de overflow,
V será igual 1 se houver uma transição de "0" para 1 do bit número
15 do par de registos HL depois de efectuada a operação. A flag N terá
invariavelmente o valor "0", enquanto que a flag de carry será
colocada a 1 sempre que houver um transporte do bit 15 para um terceiro hipotético
byte.
Na figura 15 estão assinalados alguns exemplos de
como as flags são afectadas por esta instrução. À excepção da flag H a
filosofia de activação das restantes flags é a mesma que para a adição com
carry de oito bits.
Na tabela 23 encontram-se representados os códigos
das instruções ADC de 16 bits.
3) SBC: Subtracção com carry de dois pares de
registos A instrução S13C subtrai ao par HIL o conteúdo de um par de registos
(BC, DE, HL, SP) e o valor da flag de carry. É uma instrução de dois bytes,
formalmente idêntica à instrução ADC de 16 bits, e em que o segundo byte
determina o par de registos (ou registo SP) subtractor:
Para esta instrução os bits do registo de flags são
modificados do seguinte modo:
As flags com significado para esta operação (S, Z,
V, N e C) seguem os princípios já enunciados a propósito da instrução SBC
de oito bits. A diferença reside no facto de ser o bit número 15, do par HL, o
mais significativo e, portanto, o definidor do sinal do número binário. A flag
C é colocada a 1 se o valor absoluto do par subtractor mais o valor da flag C,
anterior à operação, for maior do que o valor absoluto do par HL.
Na tabela 23 encontram-se representados os códigos
hexadecimais das instruções SBC.
4) INC. incremento de um par de registos ou de um
registo de 16 bits Existem dois tipos de instrução INC de 16 bits consoante se
pretenda incrementar um par de registos ou um registo de índice de dezasseis
bits. No primeiro caso o código de instrução é formado por um único byte,
para no segundo ser constituído por dois bytes.
As instruções INC de 16 bits, ao contrário das de
oito bits, não afectam qualquer dos bits do registo de flag.
Os códigos binários destas instruções são os
seguintes:
Na tabela 23 encontra-se um resumo dos códigos das
instruções DEC.
5) DEC: decremento de um par de registos ou de
um registo de 16 bits.
As instruções DEC de 16 bits são formalmente idênticas
às instruções INC. Existem dois tipos de instrução consoante se pretenda
decrementar um par de registos (instrução de um byte) ou um registo de índice
(instrução de dois bytes).
Ao contrário das instruções DEC de oito bits, as
instruções DEC de 16 bits não afectam o registo de flags.
Os códigos binários destas instruções são os
seguintes:
Na tabela 23 encontra-se um resumo dos códigos das
instruções INC.