Objetivos
        
    
    
    
        Instruções Bit-a-bit/Bitwise
        
     
    
        
            
                Com as instruções bit-a-bit, podemos realizar as operações bit-a-bit/bitwise, 
                AND, OR e XOR e Not(Complemento), entre o acumulador e um valor de memória, 
                ou imediato. As flags Z, N, S, P, AC, C são afetadas por 
                essas instruções.
            
            Notação utilizada:
            
                
                    
                         | 
                         | 
                    
                
                
                    
                        | #$NN | 
                        Valor hexadecimal imediato | 
                    
                    
                        | M | 
                        Endereço 16-bits contido em HL | 
                    
                    
                        | R | 
                        Registrador de 8-bits | 
                    
                    
                        | #$NN ou h | 
                        Valor hexadecimal imediato | 
                    
                    
                        | ;  | 
                        Comentário | 
                    
                    
                        | Z, N, S, P, AC, Cy | 
                        Flags | 
                    
                    
                        | Acc. ou A | 
                        Acumulador | 
                    
                    
                        | | | 
                        Concatenação | 
                    
                    
                        | <- | 
                        Atribuição | 
                    
                    
                        | & | 
                        E bit-a-bit | 
                    
                    
                        | | | 
                        OU bit-a-bit | 
                    
                    
                        | ^ | 
                        Ou exclusivo bit-a-bit | 
                    
                    
                        | ~ | 
                        Não bit-a-bit | 
                    
                    
                        | 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 e Flags.
            
         
     
    
    
        
            
                Com as instruções ANA e ANI aplicamos a operação E bit-a-bit entre o registrador Acumulador e um registrador, valor 
                imediato ou valor em memória apontando por H(HL). 
            
            
                Não é possível utilizar os pares de registadores BC e DE com essas
                instruções.
            
            Tabela verdade:
            0 AND 0 = 0
0 AND 1 = 0
1 AND 0 = 0
1 AND 1 = 1
            Operação
            A <- A & R
A <- A & M(HL)
A <- A & #$NN
            Endereçamento:
            
                
                
                
                    
                        | Registrador | 
                        ANA R | 
                    
                    
                        | Imediato | 
                        ANI $NN | 
                    
                    
                        | Indireto | 
                        ANA M | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:- 
P: a
Cy:-
            Ex:
            
MVI A, #$02
MVI B,#$0F
ANA B ; A = 2
         
     
    
    
        
            
                Com as instruções ORA/ORI aplicamos a operação OU bit-a-bit entre o registrador 
                Acumulador e um registrador, valor imediato ou valor em memória apontando por H(HL). 
            
            Tabela verdade:
            0 OR 0 = 0
0 OR 1 = 1
1 OR 0 = 1
1 OR 1 = 1
            Operação
            A <- A | R
A <- A | M(HL)
A <- A | #$NN
            Endereçamento:
            
                
                
                
                    
                        | Registrador | 
                        ORA R | 
                    
                    
                        | Imediato | 
                        ORI $NN | 
                    
                    
                        | Indireto | 
                        ORA M | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:- 
P: a
Cy:-
            Ex:
            MVI A, #$A0
MVI B,#$0B
ORA B ; A = AB
         
     
    
        XOR - OU Exclusivo bit-a-bit
        
     
    
        
            
                Com as instruções XRA/XRI aplicamos a operação OU Exclusivo bit-a-bit entre o registrador 
                Acumulador e um registrador, valor imediato ou valor em memória apontando por H(HL). 
            
            Tabela verdade:
            0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
            Operação
            A <- A ^ R
A <- A ^ M(HL)
A <- A ^ #$NN
            Endereçamento:
            
                
                
                
                    
                        | Registrador | 
                        XRA R | 
                    
                    
                        | Imediato | 
                        XRI $NN | 
                    
                    
                        | Indireto | 
                        XRA M | 
                    
                
            
            F(Flags)
            S: a
Z: a 
Ac:- 
P: a
Cy:-
            Ex:
            
MVI A, #$A0
MVI B,#$0B
XRA B ; A = AB
            
                As instruções XOR pode ser utilizada para "zerar" ou "limpar" o conteúdo do registrador A. Para isso, 
                basta utilizá-lo como operando.
            
            Ex:
            MVI A, #$A0
XRA A ; A = 0
         
     
    
        NOT - Não bit-a-bit - Complemento de 1
        
     
    
        
            
                Com a instrução NOT, podemos aplicamos a operação Não bit-a-bit com o conteúdo do Acumulador. 
                Outros registradores além do registrador A, valor imediato e em memória não são suportados.
            
            Operação
            A <- ~A
1 -> 0
0 -> 1
            Endereçamento:
            
            F(Flags)
            S: a
Z: a 
Ac:- 
P: a
Cy:-
            Ex:
            MVI A, #$F0
NOT ; A = 0F
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 12/12/2024 - revisão 5 - Adição de tabelas verdade
 
                - 04/12/2024 - revisão 4 - Correção em nome instrução Not em link, título e descrição
 
                - 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.