Objetivos
        
    
    
    
    
        
            
                Com as instruções bit-a-bit/bitwise ou lógicas, podemos realizar as operações E, OU Não e OU exclusivo bit-a-bit, 
                entre o acumulador e um valor de memória. Apenas as flags N e Z são afetadas por estas instruções, 
                com exceção da instrução BIT.
            
            Notação utilizada:
            
                
                    
                         | 
                         | 
                    
                
                
                    
                        | #$NN | 
                        Valor hexadecimal imediato | 
                    
                    
                        | #$NNNN; | 
                        Endereço hexadecimal imediato | 
                    
                    
                        | $NNNN | 
                        Endereço hexadecimal | 
                    
                    
                        | $NN ou h | 
                        Valor hexadecimal | 
                    
                    
                        | ;  | 
                        Comentário | 
                    
                    
                        | N,Z,V | 
                        Flags | 
                    
                    
                        | Acc. | 
                        Acumulador | 
                    
                    
                        | | | 
                        Concatenação | 
                    
                    
                        | <- | 
                        Atribuição | 
                    
                    
                        | & | 
                        E bit-a-bit | 
                    
                    
                        | | | 
                        OU bit-a-bit | 
                    
                    
                        | ^ | 
                        Ou exclusivo 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.
            
         
     
    
        AND - Logical And / E Lógico / E bit-a-bit
        
     
    
        
            
                Com a instrução AND aplicamos a operação E bit-a-bit entre o registrador Acumulador e um valor contido em um 
                endereço de memória ou imediato. As flags N e C são atualizadas de acordo com o resultado.
            
            Operação
            A <- A & M
            F(Flags)
            N: a
V: -
B: - 
D: -
Z: a
C:-
            Endereçamento:
            
                
                
                
                    
                        | Imediato | 
                        AND #$NN | 
                    
                    
                        | Página Zero | 
                        AND $NN | 
                    
                    
                        | Página Zero,X | 
                        AND $NN,X | 
                    
                    
                        | Absoluto | 
                        AND $NNNN | 
                    
                    
                        | Absoluto,X | 
                        AND $NNNN,X | 
                    
                    
                        | Absoluto,Y | 
                        AND $NNNN,Y | 
                    
                    
                        | Indireto X | 
                        AND ($NN,X) | 
                    
                    
                        | Indireto Y | 
                        AND ($NN),Y | 
                    
                
            
            
                Tab. 1: Registrador A - 0xCC
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        1 | 
                        0 | 
                        0 | 
                        1 | 
                        1 | 
                        0 | 
                        0 | 
                    
                
            
            
                Tab.2: Valor - 0xAA
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                    
                
            
            
                Tab. 3: Resultado - 0x88
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        0 | 
                        0 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                    
                
            
            Ex:
            
LDA #$00
AND #$0F
         
     
    
        ORA - Logical Inclusive OR / OU Lógico / OU bit-a-bit
        
     
    
        
            
                Com a instrução ORA aplicamos a operação OU bit-a-bit entre o registrador Acumulador e um valor contido em um endereço 
                de memória ou imediato. As flags N e C são atualizadas de acordo com o resultado.
            
            Operação
            A <- A | M
            F(Flags)
            N: a
V: -
B: - 
D: -
Z: a
C:-
            Endereçamento:
            
                
                
                
                    
                        | Imediato | 
                        ORA #$NN | 
                    
                    
                        | Página Zero | 
                        ORA $NN | 
                    
                    
                        | Página Zero,X | 
                        ORA $NN,X | 
                    
                    
                        | Absoluto | 
                        ORA $NNNN | 
                    
                    
                        | Absoluto,X | 
                        ORA $NNNN,X | 
                    
                    
                        | Absoluto,Y | 
                        ORA $NNNN,Y | 
                    
                    
                        | Indireto X | 
                        ORA ($NN,X) | 
                    
                    
                        | Indireto Y | 
                        ORA ($NN),Y | 
                    
                
            
            
                Tab. 4: Registrador A - 0xCC
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        1 | 
                        0 | 
                        0 | 
                        1 | 
                        1 | 
                        0 | 
                        0 | 
                    
                
            
            
                Tab.5: Valor - 0xAA
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                    
                
            
            
                Tab. 6: Resultado - 0xEE
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        1 | 
                        1 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        0 | 
                    
                
            
            Ex:
            
LDA #$01
ORA $00
         
     
    
        EOR - Exclusive OR / OU Exclusivo / OU Exclusivo bit-a-bit
        
     
    
        
            
                Com a instrução EOR aplicamos a operação Ou Exclusivo bit-a-bit entre o registrador Acumulador e um valor 
                contido em um endereço de memória. As flags N e C são atualizadas de acordo com o resultado.
            
            Operação
            A <- A ^ M
            F(Flags)
            N: a 
V: -
B: - 
D: -
Z: a
C:-
            Endereçamento:
            
                
                
                
                    
                        | Imediato | 
                        EOR #$NN | 
                    
                    
                        | Página Zero | 
                        EOR $NN | 
                    
                    
                        | Página Zero,X | 
                        EOR $NN,X | 
                    
                    
                        | Absoluto | 
                        EOR $NNNN | 
                    
                    
                        | Absoluto,X | 
                        EOR $NNNN,X | 
                    
                    
                        | Absoluto,Y | 
                        EOR $NNNN,Y | 
                    
                    
                        | Indireto X | 
                        EOR ($NN,X) | 
                    
                    
                        | Indireto Y | 
                        EOR ($NN),Y | 
                    
                
            
            
                Tab. 7: Registrador A - 0xCC
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        1 | 
                        0 | 
                        0 | 
                        1 | 
                        1 | 
                        0 | 
                        0 | 
                    
                
            
            
                Tab.8: Valor - 0xAA
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                    
                
            
            
                Tab. 9: Resultado - 0x66
                
                    
                        | Bit7 | 
                        Bit6 | 
                        Bit5 | 
                        Bit4 | 
                        Bit3 | 
                        Bit2 | 
                        Bit1 | 
                        Bit0 | 
                    
                
                
                    
                        | 0 | 
                        1 | 
                        1 | 
                        0 | 
                        0 | 
                        1 | 
                        1 | 
                        0 | 
                    
                
            
            Ex:
            
LDA #$00
EOR #$FF ; Inverte os bit de A
         
     
    
        BIT / Bit Test / Teste de Bit
        
     
    
        
            
                Com a instrução BIT podemos testar os bits de um valor em memória. Uma operação
                AND é realizar com o Acumulador e o resultado é descartado e usado apenas para 
                atualizar a flag Z, N e V. 
            
            
                A flag Z é atribuída de acordo com o resultado do AND. Os bits 7 e 6
                do valor contido na memória são transferidos para as flags N e V respectivamente.
            
            Operação
            N <- M(Bit 7)
V <- M(Bit 6)
Z <- A & M
            F(Flags)
            N: bit 7 de M 
V: bit 6 de M
B: - 
D: -
Z: a
C:-
            Endereçamento
            
                
                
                
                    
                        | Página Zero | 
                        BIT $NN | 
                    
                    
                        | Absoluto | 
                        BIT $NNNN | 
                    
                
            
            Ex:
            
;RAM[0000] = 0xFF
LDA #$80
BIT $00
BIT $0200
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 12/03/2025 - revisão 3 - correção de nome de instrução EOR de tópico OR; Ajustes pontuais
 
                - 11/09/2024 - revisão 2 - adição de tabelas com exemplos e flags afetadas
 
                - 30/08/2024 - revisão 1 - Correção em links de objetivos
 
                - 28/04/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.