Objetivos
        
    
    
    
    
        
            
                As instruções aritméticas são utilizadas para realizar as operações de adição ou subtração de registradores
                e valores em memória via Acumulador. As flags 	Z, S, P, CY, Cy são afetadas por essas instruções.
            
            Notação utilizada
            
                
                    
                         | 
                         | 
                    
                
                
                    
                        | #$NN | 
                        Valor hexadecimal imediato | 
                    
                    
                        | ;  | 
                        Comentário | 
                    
                    
                        | ! | 
                        Complemento | 
                    
                    
                        | P | 
                        Registradores BC(B) , DE(D) , HL(H) e SP | 
                    
                    
                        | R | 
                        Registradores A, B, C, D, E , H e L | 
                    
                    
                        | M | 
                        Endereço 16-bits contido em HL | 
                    
                    
                        | Flags | 
                         | 
                    
                    
                        | a | 
                        Alterada de acordo com resultado | 
                    
                    
                        | - | 
                        Não sofre alteração | 
                    
                    
                        | 0 | 
                        Sempre zero | 
                    
                    
                        | 1 | 
                        Sempre um | 
                    
                
            
            
                Mais informações sobre os registradores e flags podem ser vistas 
                em Registradores.
            
         
     
    
        ADD - Adição sem Carry("Vai-um")
        
     
    
        
            
                A instrução ADD realiza a operação aritmética de adição entre registradores, valor imediato ou
                um valor contido em um endereço de memória. Para valores imediatos ou em memória, apenas o registrador 
                Acumulador pode ser utilizado.
            
            Operação
            R1 <- R1 + R2
A <- A + (M)
A <- A + #$NN
            Endereçamento
            
                
                
                
                    
                        | Registrador | 
                        ADD R1, R2 | 
                    
                    
                        | Indireto | 
                        ADD M | 
                    
                    
                        | Imediato | 
                        ADI $$NN | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:a
P: a
Cy:a
            Ex:
            MVI A $#01
MVI B, #$01
ADD A,B ;A = 2
         
     
    
        ADC - Adição com Carry("Vai-um")
        
     
    
        
            
                A instrução ADC é semelhante a ADD, porém a ADC utiliza o flag Carry(Cy)
                também como operando ao realiza a adição. Para valores imediatos ou em memória, apenas o registrador 
                Acumulador pode ser utilizado.
            
            Operação
            R1 <- R1 + R2 + Cy
A <- A + (M) + Cy; 
A <- A + #$NN + Cy
            Endereçamento
            
                
                
                
                    
                        | Registrador | 
                        ADC R1, R2 | 
                    
                    
                        | Indireto | 
                        ADC M | 
                    
                    
                        | Imediato | 
                        ACI $$NN | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:a
P: a
Cy:a
            Ex:
            SEC ; Carry <- 1
MVI A $#01
MVI B, #$01
ADD A,B ;A = 3
         
     
    
        SUB - Subtração sem Borrow("Vem-um")
        
     
    
        
            
                A instrução SUB realiza a operação aritmética de subtração entre registradores, valor imediato 
                ou um valor contido em um endereço de memória. Para valores imediatos ou em memória, apenas o registrador 
                Acumulador pode ser utilizado.
            
            Operação
            R1 <- R1 - R2
A <- A - (M) ; M(HL)
A <- A - #$NN
            Endereçamento
            
                
                
                
                    
                        | Registrador | 
                        SUB R1,R2 | 
                    
                    
                        | Indireto | 
                        SUB M | 
                    
                    
                        | Imediato | 
                        SBI $$NN | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:a
P: a
Cy:a
            Ex:
            MVI A $#01
MVI B, #$01
SUB A,B ; A = 0
         
     
    
        SBB - Subtração com Borrow("Vem-um")
        
     
    
        
            
                A instrução SBB é semelhante a SUB, porém a SBB utiliza o flag Carry
                como "vem-um" como operando ao realiza a subtração. Para valores imediatos e em memória, apenas 
                o registrador Acumulador pode ser utilizado.
            
            Operação
            R1 <- R1 - R2 - Cy
A <- A - (M) - Cy
A <- A - #$NN - Cy
            Endereçamento
            
                
                
                
                    
                        | Registrador | 
                        SBB R2, R1 | 
                    
                    
                        | Indireto | 
                        SBB M | 
                    
                    
                        | Imediato | 
                        SUI $#NN | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:a
P: a
Cy:a
            Ex:
            SEC ; Carry <- 1
MVI A $#01
MVI B, #$01
SBB A,B
         
     
    
        DAD - Adição Dupla(16-bits) sem Carry
        
     
    
        
            
                A instrução DAD realiza a operação aritmética de adição do registrador HL com os 
                pares de registradores H, B, D, e o registrador SP. 
                Apenas a flag Carry(Cy) é alterada por essa instrução.
            
            Operação
            HL <- HL + P
            Endereçamento
            
            F(Flags)
            S: -
Z: -
Ac:-
P: -
Cy:a
            Ex:
            LXI B, $#0001
LXI H, #$0001
DAD B ; HL = 0002
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 13/12/2024 - revisão 5 - Correção em 'operação' SUB e SBB
 
                - 05/12/2024 - revisão 4 - Correção em intro; ajustes pontuais
 
                - 09/09/2024 - revisão 3 - Correção em erros gramaticais, adição de flags afetadas
 
                - 30/08/2024 - revisão 2 - Correção em links de objetivos
 
                - 04/10/2023 - revisão 1 - adição de links, correção em layout e navegação
 
                - 08/08/2023 - versão inicial
 
            
         
     
    
            
            
                
                    
                    Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
                em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.