Objetivos
        
    
    
        
            Clique sobre os objetivos listados abaixo para navegar até o conteúdo desejado.
            
         
     
    
        
Instruções de Movimentação e Troca
    
    
        
            
                Com as instruções de movimentação podemos movimentar dados entre os registradores A, B, C, D, E, H, L e memória 
                via par HL(M).
                Nenhuma flag é alterada pelas intruções de movimentação.
            
            As instruções de troca, são aquelas responsáveis pela troca de valores entres pares de registrados DE,HL e SP. 
            Notação utilizada
            
                
                    
                         | 
                         | 
                    
                
                
                    
                        | M | 
                        Endereço de memória | 
                    
                    
                        | <- | 
                        Atribuição | 
                    
                    
                        | <-> | 
                        Troca de valores | 
                    
                    
                        | ; | 
                        Comentário | 
                    
                    
                        | R | 
                        Registradores 8-bits | 
                    
                    
                        | P | 
                        Registradores BC(B), DE(D) e  HL  | 
                    
                    
                        | M | 
                        Endereço contido em HL | 
                    
                    
                        | #$NNNN | 
                        Endereço 16-bits | 
                    
                    
                        | () | 
                        conteúdo de endereço | 
                    
                
            
            
                Mais informações sobre os registradores e flags podem ser vistas 
                em Registradores e Flags.
            
         
     
    
    
        
            
                A instrução MOV é utilizado para mover valores entre registradores e registrador para memória. Essa 
                instrução utiliza apenas os registradores de 8 bits A, B, C, D, E, H e L e nenhuma flag é não altera.
            
            Operação
            R1 <- R2
(M) <- R
R <- (M)
            Endereçamento:
            
                
                
                
                    
                        | Registrador | 
                        MOV R1, R2 | 
                    
                    
                        | Indireto | 
                        MOV M, R | 
                    
                    
                        | Indireto | 
                        MOV R, M | 
                    
                
            
            Exemplo:
            
MOV B,C ; 
MOV B,B
MOV H,L
         
     
    
        MVI - Move Immediate - Mover Imediato
        
     
    
        
            
                A instrução MVI é semelhante a MOV, porém um valor imediato de 8-bits é movido para um 
                um registrador de 8-bits de destino ou memória.
            
            Operação
            R <- #byte_imediato
M <- #byte_imediato
            Endereçamento:
            
                
                
                
                    
                        | Imediato | 
                        MVI R, #$NN | 
                    
                    
                        | Imediato | 
                        MVI M, #$NN | 
                    
                
            
            Exemplo:
            
MVI A,#$01
MVI C,#$00	
         
     
    
        LDA - Carregar Registrador Acumulador
        
     
    
        
            
                Utilizando a instrução LDA, podemos mover um valor 8-bits contido em um endereço de memória 
                para o registrador A. Esse endereço é informado utilizando o endereçamento direto imediato.
            
            Operação
            A <- ($NNNN)
            Endereçamento:
            
            Exemplo:
            
;...
LDA $FFFF	;Carrega A com valor contido em $FFFF
         
     
    
        LDAX - Carrega A via Par de registrador
        
     
    
        
            
                A instrução LDAX é semelhante a instrução LDA, porém os apenas os pares de 
                registradores B(BC) e D(DE) são utilizados como endereço
                de memória para recuperar um valor de 8-bis que será transferido para o registrador A. 
            
            Operação
            A <- P
            Endereçamento:
            
            Exemplo:
            
LDAX B	; A <- (BC)
LDAX D	; A <- (DE)
         
     
    
        STA - Store Accumulator - Armazena A em memória
        
     
    
        
            
                Utilizando a instrução STA, podemos mover um valor 8-bits contido no registrador A para um endereço 
                de memória imediato. Esse endereço é informado utilizando o endereçamento direto imediato.
            
            Operação
            ($NNNN) <- A
            Endereçamento:
            
            Exemplo:
            
MVI A,#$FF
STA $FFFF	;Carrega A com valor contido em $FFFF
         
     
    
        STAX - Armazena A em memória via Par de registrador
        
     
    
        
            
                A instrução STAX é semelhante a instrução STA, porém, apenas os pares de registradores 
                B(BC) e D(DE) são utilizados como endereço de memória para armazenar um valor de 8-bits 
                contido no registrador A. 
            
            Operação
            (P) <- A
            Endereçamento:
            
            Exemplo:
            
MVI A, #$FF 
STAX B; (BC) <- A
STAX D; (DE) <- A
         
     
    
        LXI - Move valor 16-bits imediato
        
     
    
        
            
                A instrução LXI move um valor ou endereço de 16-bits para um dos registradores 
                HL(H), BC(B) ,DE(D) e SP apenas. Esse endereço é informado utilizando o endereçamento direto imediato.
            
            Operação
            P <- #$NNNN
SP <- #$NNNN
            Endereçamento:
            
                
                
                
                    
                        | Imediato | 
                        LXI P, #$NNNN | 
                    
                    
                        | Imediato | 
                        LXI SP, #$NNNN | 
                    
                
            
            Exemplo:
            
LXI H,#$FFFF
LXI SP,#$FFFF
         
     
    
        LHLD - Move endereço 16-bits para HL
        
     
    
        
            
                A instrução LHLD move um valor de 16-bits apontado por endereço de memória e armazena 
                esse valor em HL. Esse endereço é informado utilizando o endereçamento direto imediato.
            
            Operação
            HL <- ($NNNN)
            Endereçamento:
            
            Exemplo:
            MVI A, #$01
STA $FFFE
MVI A, #$FF
STA $FFFF
LHLD $FFFE ; HL <- $01ff
         
     
    
        SHLD - Move HL para memória 
        
     
    
        
            
                Com a instrução SHLD, podemos mover um valor de 16-bits contido em HL(M) para um endereço de memória.
                Esse endereço é informado utilizando o endereçamento direto imediato. 
            
            Operação
            ($NNNN) <- HL
            Endereçamento:
            
            Exemplo:
            MVI  H, #$01
MVI  L, #$FF
SHLD $FFFE ; (FFFE) <- 01ff
         
     
    
    
        
            
                Fazendo uso da instrução XCHG trocar ou permutar os valores contido nos pares de registradores 
                D(DE) e HL apenas. Essa instrução não possui operandos.
            
            Operação
            DE <-> HL
            Endereçamento:
            
            Exemplo:
            LXI D,#$0001
LXI H,#$0002
XCHG
         
     
    
    
        
            
                A instrução PCHL move o valor contido no registrador HL para o registrador Contador de Programa(PC). 
                Essa instrução é utilizada para desviar o fluxo de execução do programa e não possui operandos.
            
            Operação
            PC <-> HL
            Endereçamento:
            
            Exemplo:
            MVI H, #$01
MVI L, #$FF
PCHL    ; desvia p/ $01FF
         
     
    
        XTHL - Troca conteúdo de SP com HL 
        
     
    
        
            
                A instrução PCHL faz a permuta entre de valores 16-bits entre o par de registradores HL com 
                um valor contido na pilha. Nenhuma flag é alterada por essa instrução.
            
            Operação
            H <-> (SP + 1)
L <-> (SP)
            Endereçamento:
            
            Exemplo:
            LXI B,#$AABB
PUSH B
LXI H,#$CCDD
XTHL
;HL = AABB
;(SP + 1) = DD
;(SP) = CC
         
     
    
        LDHL - Carrega endereço em HL 
        
     
    
        
            
                A instrução LHLD carregar no par HL um valor 16-bits contido em um endereço de memória passado como 
                argumento de forma imediata. Nenhuma flag é alterada por essa instrução.
            
            Operação
            H <-> (endereço_imediato + 1)
L <-> (endereço_imediato)
            Endereçamento:
            
            Exemplo:
            LXI H, #$F000
MVI M, #$FE
INR L
MVI M, #$FF
LDHL
;HL = FFFE
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 18/03/2025 - revisão 4 - adição de instruções XTHL e LDHL
 
                - 13/12/2024 - revisão 3 - correções, melhorias e ajustes pontuais
 
                - 09/09/2024 - revisão 2 - correção em LDAX, STA, STAX e LXI
 
                - 04/10/2023 - revisão 1 - adição de links, correção em layout, navegação e erro gramaticais 
 
                - 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.