Objetivos
        
    
    
    
        
Instruções de Pilha/Stack
    
    
        
            
                As instruções que manipulam a pilha são responsáveis por escrever e recuperar dados da pilha. Normalmente utilizadas 
                para realizar backup de registradores. Nenhuma flag é afetada, exceto por PLA e PLP, por esse tipo de instruções.
            
            
                Nas instruções de PUSH o registrador SP é decrementado e nas instruções de PULL o SP 
                é incrementado.
            
            
                Para transferir os valores dos registradores X, Y e SP é necessário transferí-los para o registrador A antes.
                Ver instruções de Transferência.
            
            Notação utilizada:
            
                
                    
                         | 
                         | 
                    
                
                
                    
                        | #$NN | 
                        Valor hexadecimal imediato | 
                    
                    
                        | MNEMÔNICO | 
                        Abreviação do nome de uma instrução | 
                    
                    
                        | ; | 
                        Comentário | 
                    
                    
                        | () | 
                        Conteúdo de memória | 
                    
                    
                        | <- | 
                        Atribuição | 
                    
                    
                        | M | 
                        Endereço de Memória em | 
                    
                    
                        | Flags | 
                         | 
                    
                    
                        | a | 
                        Alterada de acordo com resultado | 
                    
                    
                        | - | 
                        Não sofre alteração | 
                    
                    
                        | 0 | 
                        Sempre zero | 
                    
                    
                        | 1 | 
                        Sempre um | 
                    
                
            
            
                Mais informações sobre os registradores, flags e pilha podem ser vistas 
                em Registradores e 
                Pilha.
            
         
     
    
        PHA - Push Accumulator On Stack
        
     
    
        
            
                Com essa instrução PHA, podemos transferir o valor contido no registrador A para o topo da Stack/Pilha.
            
            Operação
            (SP) <- A
SP <- SP - 1
            Endereçamento:
            
            F(Flags)
            N: -
V: -
B: - 
D: -
Z: -
C:-
            Ex:
            
LDA #$FF
PHA
         
     
    
        PHP - Push Processor Status On Stack
        
     
    
        
            
                Com a instrução PHP, podemos transferir um valor do registrador PS para o topo da Stack. 
            
            Operação
            (SP) <- PS
SP <- SP - 1
            Endereçamento:
            
            F(Flags)
            N: -
V: -
B: - 
D: -
Z: -
C:-
            Ex:
            
LDY #$FF
TYA
PHP
; trecho omitido
PLP
         
     
    
        PLA - Pull Accumulator From Stack
        
     
    
        
            
                A instrução PLA é utilizada para recuperar o valor do topo da Stack e transferí-lo para o registrador A. As flags
                N e Z são atualizadas de acordo com valor transferido para A.
            
            Operação
            A <- (SP)
SP <- SP + 1
            Endereçamento:
            
            F(Flags)
            N: a
V: -
B: - 
D: -
Z: a
C:-
            Ex:
            
PHA ;salva A
; trecho de código omitido
PLA ; restaura A
         
     
    
        PLP - Pull Processor Status From Stack
        
     
    
        
            
                A instrução PLP é utilizada para recuperar o valor do topo da Stack e transferi-lo para o registrador PS. 
                Os Bits 5 e 4 são ignorados.
            
            Operação
            PS <- (SP)
SP <- SP + 1
            Endereçamento:
            
            F(Flags)
            N: 
V: -
B: - 
D: -
Z: -
C:-
            Ex:
            
PHP
; trecho omitido
PLP
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 12/03/2025 - revisão 4 - Correção em flags afetadas na introdução; Ajustes pontuais
 
                - 11/09/2024 - revisão 3 - 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
 
                - 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.