ARMv1.doc

ARMv1 ISA

Mnemonic

Syntax

Description

Action

Movement Instructions
Movement instructions move data between registers and operands.

MOV

MOV<cond>{S} Rd, #imm

Move value immed

Rd = immed

MOV

MOV<cond>{S} Rd, Rm{, <shift>}

Move value

Rd = Shift(Rm)

MVN

MVN<cond>{S} Rd, #imm

Move NOT value immed

Rd = ¬immed

MVN

MVN<cond>{S} Rd, Rm{, <shift>}

Move NOT value

Rd = ¬Shift(Rm)

Load Instructions
Load instructions move the content of memory addresses into registers.

LDM

LDM<cond><type> Rn{!}, <reglist>{^}

Load multiple

addr = Rn
for each Rd in {reglist}:
     Rd = [addr]
     update address based on {type}

LDR

LDR<cond>{B} Rd, [Rn{, #imm}]{!}

Load register immed

Rd = [Rn + imm]
If !: Rn = Rn + imm

LDR

LDR<cond>{B} Rd, [Rn, Rm{, <shift>}]{!}

Load register

Rd = [Rn + Shift(Rm)]
If !: Rn = Rn + Shift(Rm)]

LDR

LDR<cond>{B}{T} Rd, [Rn], #imm

Load register, post index

Rd = [Rn]
Rn = Rn + imm

LDR

LDR<cond>{B}{T} Rd, [Rn], Rm{, <shift>}

Load register, post index

Rd = [Rn]
Rn = Rn + Shift(Rm)

Store Instructions
Store instructions moves the values from registers into memory.

STM

STM<cond><type> Rn{!}, <reglist>{^}

Store multiple

addr = Rn
for each Rd in {reglist}:
     [addr] = Rd
     update address based on {type}

STR

STR<cond>{B} Rd, [Rn{, #imm}]{!}

Store register immed

[Rn + imm] = Rd
If !: Rn = Rn + imm

STR

STR<cond>{B} Rd, [Rn, Rm{, <shift>}]{!}

Store register

[Rn + Shift(Rm)] = Rd
If !: Rn = Rn + Shift(Rm)]

STR

STR<cond>{B}{T} Rd, [Rn], #imm

Store register, post index

[Rn] = Rd
Rn = Rn + imm

STR

STR<cond>{B}{T} Rd, [Rn], Rm{, <shift>}

Store register, post index

[Rn] = Rd
Rn = Rn + Shift(Rm)

Arithmetic Instructions
Arithmetic instructions perform basic mathematical operations on two operands.

ADC

ADC<cond>{S} Rd, Rn, #imm

Add and carry immed

Rd = Rn + imm + C

ADC

ADC<cond>{S} Rd, Rn, Rm{, <shift>}

Add and carry

Rd = Rn + Shift(Rm) + C

ADD

ADD<cond>{S} Rd, Rn, #imm

Add immed

Rd = Rn + imm

ADD

ADD<cond>{S} Rd, Rn, Rm{, <shift>}

Add

Rd = Rn + Shift(Rm)

RSB

RSB<cond>{S} Rd, Rn, #imm

Reverse subtract immed

Rd = imm − Rn

RSB

RSB<cond>{S} Rd, Rn, Rm{, <shift>}

Reverse subtract

Rd = Shift(Rm) − Rn

RSC

RSB<cond>{S} Rd, Rn, #imm

Reverse subtract with carry immed

Rd = imm − Rn − ¬C

RSC

RSB<cond>{S} Rd, Rn, Rm{, <shift>}