Com as instruções de movimentação podemos mover dados entre os registradores D0-7 ou A0-7, ler dados do SR e dados para o CCR. As instruções move compreendem: MOVE, MOVEA, MOVEM, MOVEQ, MOVEP.

As instruções de permuta, são aquelas responsáveis pela troca de valores entres registradores ou words de um registrador. EXG e SWAP compreendem as intruções de permuta.

Abaixo, a notação utilizada ao longo dos tópicos abordados nesta parte do tutorial:

Para informações sobre registradores visite Registradores. Para mais informações sobre modos de endereçamento visite Modos de Endereçamento.

Com a instrução MOVE podemos movimentar dados entre os registradores D0-7 ou A0-7. As flags N e Z são alteradas por essa instrução.

Operação

origem -> destino

Endereçamento Origem

Dx, Ax, (Ax), (Ax)+, ‑(Ax), n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx[.W|.L]|Ax[.W|.L]) e #imediato

Endereçamento Destino

Dx, Ax, (Ax), (Ax)+, ‑(Ax), n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx|Ax) e #imediato

Tamanho do dado

Byte, Word e Longword

CCR

X: -
N: a
Z: a 
V: 0
C: 0

Sintaxe

MOVE.B Dx,Dy ; Dx origem / Dy destino
MOVE.L  (Ax),Dx
MOVE.W -(Ax),Dx
MOVE.B (Ax)+,Dx
MOVE  #$imediato,Dx

Exemplo:

; D0 = 123456FF D1 = FFEEDD00
MOVE.B D0,D1 ;
; D0 = 123456FF D1 = FFEEDDFF
    
MOVE.L  (A0),D2
MOVE.W -(A1),D3
MOVE.B (A3)+,D4
MOVE.W  #FFFF,D5

O mesmo que a instrução MOVE, porém o CCR é utilizado como destino. Como o CCR é composto de apenas 1 byte, o byte mais significativo da origem é descartado.

Operação

origem -> CCR

Endereçamento origem

Dx, Ax, (Ax), (Ax)+, ‑(Ax), n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx|Ax) e #imediato

Tamanho dos dados

Word

CCR

X: a
N: a
Z: a 
V: a
C: a

Sintaxe

MOVE.W Dx,CCR
MOVE.W  (Ax),CCR
MOVE.W -(Ax),CCR
MOVE.W (Ax)+,CCR

Exemplo:

;CCR = 00011011b
MOVE.W #$2700, CCR
;CCR = 0000000b

MOVE.W D0, CCR
MOVE.W  (A0), CCR
MOVE.W -(A1), CCR
MOVE.W (A3)+, CCR

O mesmo que a instrução MOVE, porém, o SR é utilizado como destino. Como o SR é composto de 2 bytes, a Word é movida da origem para SR.

Operação

origem -> SR

Endereçamento origem

Dx, Ax, (Ax), (Ax)+, ‑(Ax), n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx[.W|.L]|Ax[.W|.L]) e #imediato

Tamanho do dado

Word

CCR

X: a
N: a
Z: a 
V: a
C: a

Sintaxe

MOVE.W Dx,SR
MOVE.W  (Ax),SR
MOVE.W -(Ax),SR
MOVE.W (Ax)+,SR

Exemplo:

MOVE.W #$2700, SR
MOVE.W D0,SR
MOVE.W  (A0),SR
MOVE.W -(A1),SR
MOVE.W (A3)+,SR

O mesmo que a instrução MOVE, porém, o SR é utilizado como origem. Como o SR é composto de 2 bytes, a Word é movida para o registrador de destino.

Operação

SR -> destino

Endereçamento Destino

Dx, Ax, (Ax), (Ax)+, ‑(Ax), n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx|Ax) e #imediato

Tamanho do dado

Word

CCR

X: -
N: -
Z: -
V: -
C: -

Sintaxe

MOVE SR, Dx
MOVE SR, (Ax)
MOVE SR, -(Ax)
MOVE SR, (Ax)+

Exemplo:

MOVE SR, D0
MOVE SR, (A0)
MOVE SR, -(A1)
MOVE SR, (A2)+

A instrução MOVEA é semelhante a instrução MOVE, mas trabalha apenas com os registradores A0-7 movendo um valor Word(Sinalizado) ou Longword para um registrador de destino.

Caso um dado Word seja utilizado, o bit mais significativo é estendido no destino formando um valor de 32-Bits.

Para carregamento de endereços de variáveis, arrays e outros recursos, a instrução LEA deve ser utilizada para que não ocorra a extensão do endereço.

Operação

origem -> Ax

Endereçamento Origem

Dx, Ax, (Ax), (Ax)+, ‑(Ax), n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx[.W|.L]|Ax[.W|.L]) e #imediato

Endereçamento Destino

Ax

Tamanho do dado

Word e Longword

Sintaxe

MOVEA #imediato, Ax
MOVEA Ax, Ay
MOVEA Ax, (Ay)
MOVEA Ax, -(Ay)
MOVEA Ax, (Ay)+

CCR

X: -
N: -
Z: -
V: -
C: -

Exemplo:

; A0 = 00000000
MOVEA #3FFF,A0
; A0 = 00003FFF

; A0 = 00000000
MOVEA #8000,A0
; A0 = FFFF8000

A instrução MOVEM é semelhante a instrução MOVE, mas consegue mover um grupo de registradores para ou de um endereço de memória que é incrementada ou decrementada, de acordo com os tamanho informados, até o último registrador movido ou recuperado.

Os registradores são armazenados na ordem que são informados e devem ser recuperados na mesma ordem para evitar inconsistências.

Caso um dado Word de origem seja recuperado de um endereço de memória, o bit mais significativo é estendido no registrador de destino formando um valor de 32-Bits.

Operação

Dx-Dy -> destino
Ax-Ay -> destino
Dx-Dy/Ax-Ay -> destino
Dx/Dy/Ax/Ay -> destino

Endereçamento Origem

(Ax), (Ax)+, n(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L, n(PC), n(PC,Dx[.W|.L]|Ax[.W|.L])

Endereçamento Destino

(Ax), n(Ax), -(Ax), n(Ax,Dx[.W|.L]|Ax[.W|.L]), absoluto.W, absoluto.L

Tamanho do dado

Word e Longword

Sintaxe

MOVEM.L Di-Df,-(Ax)
MOVEM.L absoluto,Di-Df; 

CCR

X: -
N: -
Z: -
V: -
C: -

Exemplo:

; D0 = CCDDEEFF D1 = 8899AABB   
; $8000 = 00000000, $8004 = FFFFFFFF

MOVEM.L D0-D1,$8000

; $8000 = CCDDEEFF $8004 = 8899AABB

MOVE $8000,D0-D1

Com instrução MOVEQ é semelhante a instrução move, porém move um valor imediato sinalizado de 8-bits para um registrador de dados D0-7. Todo o registrador de destino é alterado, pois MOVEQ trabalha apenas com dado Longword.

Operação

#imediato -> destino

Endereçamento Origem

#imediato

Endereçamento Destino

Dx

Tamanho do dado

Longword

CCR

X: -
N: a
Z: a
V: 0
C: 0

Sintaxe

MOVEQ #imediato,Dx

Exemplo:

; D0 = FFFFFFFF
MOVEQ #$7,D0
; D0 = 00000007

; D1 = 000000FF
MOVEQ #$127,D1
; D1 = 0000007F

; D2 = 000000FF
MOVEQ #$-128,D2
; D2 = 00000080

A instrução EXchanGe é utilizada quando precisamos trocar os valores entre registradores D0-7 ou A0-7. Nenhuma flag é alterada por essa instrução a troca entre tipos diferentes de registradores não é permitida.

Operação

Dx <-> Dy
Ax <-> Ay

Endereçamento Origem

Dx, Ax

Tamanho do dado

Longword

CCR

X: -
N: -
Z: -
V: -
C: -

Sintaxe

EXG Dx, Dy
EXG Ax, Ay

Exemplo:

; D0 = FFFFFFFF D1 = 00000000
EXG D0, D1
; D0 = 00000000 D1 = FFFFFFFF 

A0 = FFFFFF00 D1 = 000000FF
EXG A0, A1
; A0 = 000000FF A1 = FFFFFF00

A instrução SWAP é semelhante a instrução EXG, porém é aplicada sobre os dados Word mais e menos significativos que são permutados. Essa instrução só pode ser aplicado em registradores de dados. Nenhuma flag é alterada por esse instrução.

Operação

Dx.W <-> Dx.W

Endereçamento Origem/Destino

Dx

Tamanho do dado

Word

CCR

X: -
N: -
Z: -
V: -
C: -

Sintaxe

SWAP Dx

Exemplo:

; D0 = FFFFEEEE
SWAP D0 
; D0 = EEEEFFFF 

; D1 = AAAABBBB
SWAP D1
; D1 = BBBBAAAA