| Page 1 |
A
A
d
v
a
n
c
R
e
d
R
I
S
C
M
M
a
c
h
i
n
e
s
The ARM Instruction Set
The ARM Instruction Set - ARM University Program - V1.0
1
| Page 2 |
u
t
o
i
e
A
Th
Processor Modes
* The ARM has six operating modes:
• User (unprivileged mode under which most tasks run)
• FIQ (entered when a high priority (fast) interrupt is raised)
• IRQ (entered when a low priority (normal) interrupt is raised)
• Supervisor (entered on reset and when a Software Interrupt instr
executed)
• Abort (used to handle memory access violations)
• Undef (used to handle undefined instructions)
* ARM Architecture Version 4 adds a seventh mode:
• System (privileged mode using the same registers as user mode)
RM Instruction Set - ARM University Program - V1.0
c
i
n
s
2
| Page 3 |
e
A
n
Th
*
*
RM I
The Registers
ARM has 37 registers in total, all of which are 32-bits long.
• 1 dedicated program counter
• 1 dedicated current program status register
• 5 dedicated saved program status registers
• 30 general purpose registers
However these are arranged into several banks, with the accessible
bank being governed by the processor mode. Each mode can access
• a particular set of r0-r12 registers
• a particular r13 (the stack pointer) and r14 (link register)
• r15 (the program counter)
• cpsr (the current program status register)
and privileged modes can also access
• a particular spsr (saved program status register)
struction Set - ARM University Program - V1.0
3
| Page 4 |
g
a
e
v
Re
User32 / System
r0
r1
r2
r3
r4
r5
r6
r7
r8
r9
r10
r11
r12
r13 (sp)
r14 (lr)
r15 (pc)
cpsr
The ARM Instruction Set - ARM Uni
ister Organis
General registers and Program Count
FIQ32
Supervisor32
Abort32
IRQ32
r0
r0
r0
r0
r1
r1
r1
r1
r2
r2
r2
r2
r3
r3
r3
r3
r4
r4
r4
r4
r5
r5
r5
r5
r6
r6
r6
r6
r7
r7
r7
r7
r8_fiq
r8
r8
r8
r9_fiq
r9
r9
r9
r10_fiq
r10
r10
r10
r11_fiq
r11
r11
r11
r12_fiq
r12
r12
r12
r13_fiq
r13_svc
r13_abt
r13_irq
r14_fiq
r14_svc
r14_abt
r14_irq
r15 (pc)
r15 (pc)
r15 (pc)
r15 (pc)
Program Status Registers
cpsr
cpsr
cpsr
cpsr
s
s
s
s
s
p
p
p
p
p
s
p
r
r
r
r
r
s
s
s
s
s
s
r
r
r
r
r
r
_
_
_
_
_
_
f
f
f
f
f
f
i
i
i
i
i
i
q
q
q
q
q
q
s
p
s
r
_
s
v
c
s
p
s
r
_
a
b
t
s
s
s
s
s
p
p
p
p
p
s
r
r
r
r
r
p
s
s
s
s
s
s
r
r
r
r
r
r
_
_
_
_
_
_
f
f
f
f
f
i
i
i
i
i
i
r
q
q
q
q
q
q
ersity Program - V1.0
tion
r
Undefined32
r0
r1
r2
r3
r4
r5
r6
r7
r8
r9
r10
r11
r12
r13_undef
r14_undef
r15 (pc)
cpsr
s
s
s
s
s
s
p
p
p
p
p
p
s
r
r
r
r
r
r
_
s
s
s
s
s
r
r
r
r
r
u
_
_
_
_
_
n
f
f
f
f
f
d
i
i
i
i
i
q
q
q
q
q
e
f
4
| Page 5 |
p
e
o
e
n
o
t
Registers i
r0
r1
r2
r3
r4
r5
r6
r7
r8
r9
r10
r11
r12
r13 (sp)
r14 (lr)
r15 (pc)
cpsr
The ARM Instruction Se
Register Exam
User to FIQ M
use
User Mode
FIQ M
r8_fiq
EXCEPTION
r8
r9_fiq
r9
r10_fiq
r10
r11_fiq
r11
r12_fiq
r12
r13_fiq
r13 (sp)
r14_fiq
r14 (lr)
Return address calculated from User mode
PC value and stored in FIQ mode LR
spsr_fiq
User mode CPSR copied to FIQ mode SPSR
- ARM University Program - V1.0
l
d
de
:
Registers in use
r0
r1
r2
r3
r4
r5
r6
r7
r8_fiq
r9_fiq
r10_fiq
r11_fiq
r12_fiq
r13_fiq
r14_fiq
r15 (pc)
cpsr
spsr_fiq
5
| Page 6 |
t
e
A
Th
Accessing Registers using
ARM Instructions
* No breakdown of currently accessible registers.
• All instructions can access r0-r14 directly.
• Most instructions also allow use of the PC.
* Specific instructions to allow access to CPSR and SPSR.
* Note : When in a privileged mode, it is also possible to load / store
(banked out) user mode registers to or from memory.
• See later for details.
RM Instruction Set - ARM University Program - V1.0
he
6
| Page 7 |
The Program Status Registers
(CPSR and SPSRs)
31
28
8
4
0
N Z C V
I F T
Mode
Copies of the ALU status flags (latched if the
instruction has the "S" bit set).
* Condition Code Flags
* Interrupt Disable bits.
N = Negative result from ALU flag.
I = 1, disables the IRQ.
Z = Zero result from ALU flag.
F = 1, disables the FIQ.
C = ALU operation Carried out
V = ALU operation oVerflowed
* T Bit (Architecture v4T only)
T = 0, Processor in ARM state
* Mode Bits
T = 1, Processor in Thumb state
M[4:0] define the processor mode.
The ARM Instruction Set - ARM University Program - V1.0
7
| Page 8 |
n
F
e
A
M
S
M
U
Th
R
Flag
Negative
(N=‘1’)
Zero
(Z=‘1’)
Carry
(C=‘1’)
oVerflow
(V=‘1’)
Instruction
et -
AR
Conditio
Logical Instruction
No meaning
Result is all zeroes
After Shift operation
‘1’ was left in carry flag
No meaning
niversity Program - V1.0
lags
Arithmetic Instruction
Bit 31 of the result has been set
Indicates a negative number in
signed operations
Result of operation was zero
Result was greater than 32 bits
Result was greater than 31 bits
Indicates a possible corruption of
the sign bit in signed
numbers
8
| Page 9 |
e
A
Th
The Program Counter (R15)
* When the processor is executing in ARM state:
• All instructions are 32 bits in length
• All instructions must be word aligned
• Therefore the PC value is stored in bits [31:2] with bits [1:0] equal to
zero (as instruction cannot be halfword or byte aligned).
* R14 is used as the subroutine link register (LR) and stores the return
address when Branch with Link operations are performed,
calculated from the PC.
* Thus to return from a linked branch
• MOV r15,r14
or
• MOV pc,lr
RM Instruction Set - ARM University Program - V1.0
9
| Page 10 |
d
T
e
R
*
*
The A
Exception Han
and the Vector
When an exception occurs, the core:
• Copies CPSR into SPSR_<mode>
• Sets appropriate CPSR bits
If core implements ARM Architecture 4T and is
currently in Thumb state, then
ARM state is entered.
Mode field bits
Interrupt disable flags if appropriate.
• Maps in appropriate banked registers
• Stores the “return address” in LR_<mode>
• Sets PC to vector address
To return, exception handler needs to:
• Restore CPSR from SPSR_<mode>
• Restore PC from LR_<mode>
M Instruction Set - ARM University Program - V1.0
ling
abl
0x00000000
0x00000004
0x00000008
0x0000000C
0x00000010
0x00000014
0x00000018
0x0000001C
Reset
Undefined Instruction
Software Interrupt
Prefetch Abort
Data Abort
Reserved
IRQ
FIQ
10
| Page 11 |
e
A
n
Th
*
*
RM I
The Instruction Pipeline
The ARM uses a pipeline in order to increase the speed of the flow of
instructions to the processor.
• Allows several operations to be undertaken simultaneously, rather than
serially.
ARM
PC
FETCH
Instruction fetched from memory
PC - 4
DECODE
Decoding of registers used in instruction
P
C
-
8
E
X
E
C
U
T
E
R
S
e
h
g
i
f
i
t
s
a
t
e
n
r
d
(
s
A
)
L
r
e
U
a
d
o
p
f
e
r
o
r
m
a
t
i
o
R
n
e
g
i
s
t
e
r
B
a
n
k
Write register(s) back to Register Bank
Rather than pointing to the instruction being executed, the
PC points to the instruction being fetched.
struction Set - ARM University Program - V1.0
11
| Page 12 |
Quiz #1 - Verbal
* What registers are used to store the program counter and link register?
* What is r13 often used to store?
* Which mode, or modes has the fewest available number of registers
available? How many and why?
The ARM Instruction Set - ARM University Program - V1.0
12
| Page 13 |
o
ARM Instruction Set F
31
2827
1615
87
0
Cond 0 0 I Opcode S Rn Rd Operand2
Cond 0 0 0 0 0 0 A S Rd Rn Rs 1 0 0 1 Rm
Cond 0 0 0 0 1 U A S RdHi RdLo Rs 1 0 0 1 Rm
Cond 0 0 0 1 0 B 0 0 Rn Rd 0 0 0 0 1 0 0 1 Rm
Cond 0 1 I P U B W L Rn Rd Offset
Cond 1 0 0 P U S W L Rn Register List
Cond 0 0 0 P U 1 W L Rn Rd Offset1 1 S H 1 Offset2
Cond 0 0 0 P U 0 W L Rn Rd 0 0 0 0 1 S H 1 Rm
Cond 1 0 1 L Offset
Cond 0 0 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 Rn
Cond 1 1 0 P U N W L Rn CRd CPNum Offset
Cond 1 1 1 0 Op1 CRn CRd CPNum Op2 0 CRm
Cond 1 1 1 0 Op1 L CRn Rd CPNum Op2 1 CRm
Cond 1 1 1 1 SWI Number
The ARM Instruction Set - ARM University Program - V1.0
rmat
Instruction type
Data processing / PSR Transfer
Multiply
Long Multiply
(v3M / v4 only)
Swap
Load/Store Byte/Word
Load/Store Multiple
Halfword transfer : Immediate offset (v4 only)
Halfword transfer: Register offset (v4 only)
Branch
Branch Exchange (v4T only)
Coprocessor data transfer
Coprocessor data operation
Coprocessor register transfer
Software interrupt
13
| Page 14 |
e
A
Th
Conditional Execution
* Most instruction sets only allow branches to be executed conditionally.
* However by reusing the condition evaluation hardware, ARM effectively
increases number of instructions.
• All instructions contain a condition field which determines whether the
CPU will execute them.
• Non-executed instructions soak up 1 cycle.
– Still have to complete cycle so as to allow fetching and decoding of
following instructions.
* This removes the need for many branches, which stall the pipeline (3
cycles to refill).
• Allows very dense in-line code, without branches.
• The Time penalty of not executing several conditional instructions is
frequently less than overhead of the branch
or subroutine call that would otherwise be needed.
RM Instruction Set - ARM University Program - V1.0
14
| Page 15 |
C
o
n
i
o
g
m
V
The
31
28
24
Cond
0000 = EQ - Z set (equal)
0001 = NE - Z clear (not equal)
0010 = HS / CS - C set (unsigned
higher or same)
0011 = LO / CC - C clear (unsigned
lower)
0100 = MI -N set (negative)
0101 = PL - N clear (positive or
zero)
0110 = VS - V set (overflow)
0111 = VC - V clear (no overflow)
1000 = HI - C set and Z clear
(unsigned higher)
The ARM Instruction Set - ARM University Pro
ra
-
dit
20
1.0
16
n Field
12
8
4
0
1001 = LS - C clear or Z (set unsigned
lower or same)
1010 = GE - N set and V set, or N clear
and V clear (>or =)
1011 = LT - N set and V clear, or N clear
and V set (>)
1100 = GT - Z clear, and either N set and
V set, or N clear and V set (>)
1101 = LE - Z set, or N set and V clear,or
N clear and V set (<, or =)
1110 = AL - always
1111 = NV - reserved.
15
| Page 16 |
I
*
*
The ARM
Using and updating the
Condition Field
To execute an instruction conditionally, simply postfix it with the
appropriate condition:
• For example an add instruction takes the form:
– ADD r0,r1,r2
; r0 = r1 + r2 (ADDAL)
• To execute this only if the zero flag is set:
– ADDEQ r0,r1,r2 ; If zero flag set then…
; ... r0 = r1 + r2
By default, data processing operations do not affect the condition flags
(apart from the comparisons where this is the only effect). To cause the
condition flags to be updated, the S bit of the instruction needs to be set
by postfixing the instruction (and any condition code) with an “S”.
• For example to add two numbers and set the condition flags:
– ADDS r0,r1,r2
; r0 = r1 + r2
; ... and set flags
nstruction Set - ARM University Program - V1.0
16
| Page 17 |
e
A
M
n
Th
R
I
Branch instructions (1)
* Branch :
B{<cond>} label
* Branch with Link :
BL{<cond>} sub_routine_label
31
28 27
25 24 23
0
Cond 1 0 1 L
Offset
Link bit 0 = Branch
1 = Branch with link
Condition field
* The offset for branch instructions is calculated by the assembler:
•
By taking the difference between the branch instruction and the
target address minus 8 (to allow for the pipeline).
•
This gives a 26 bit offset which is right shifted 2 bits (as the
bottom two bits are always zero as instructions are word –
aligned) and stored into the instruction encoding.
•
This gives a range of 32 Mbytes.
struction Set - ARM University Program - V1.0
17
| Page 18 |
e
A
Th
Branch instructions (2)
* When executing the instruction, the processor:
• shifts the offset left two bits, sign extends it to 32 bits, and adds it to PC.
* Execution then continues from the new PC, once the pipeline has been
refilled.
* The "Branch with link" instruction implements a subroutine call by
writing PC-4 into the LR of the current bank.
• i.e. the address of the next instruction following the branch with link
(allowing for the pipeline).
* To return from subroutine, simply need to restore the PC from the LR:
• MOV pc, lr
• Again, pipeline has to refill before execution continues.
* The "Branch" instruction does not affect LR.
* Note: Architecture 4T offers a further ARM branch instruction, BX
• See Thumb Instruction Set Module for details.
RM Instruction Set - ARM University Program - V1.0
18
| Page 19 |
n
e
A
Th
Data processing Instructions
* Largest family of ARM instructions, all sharing the same instructio
format.
* Contains:
• Arithmetic operations
• Comparisons (no results - just set condition codes)
• Logical operations
• Data movement between registers
* Remember, this is a load / store architecture
• These instruction only work on registers, NOT memory.
* They each perform a specific operation on one or two operands.
• First operand always a register - Rn
• Second operand sent to the ALU via barrel shifter.
* We will examine the barrel shifter shortly.
RM Instruction Set - ARM University Program - V1.0
19
| Page 20 |
a
i
n
e
A
Th
Arithmetic Oper
* Operations are:
• ADD
operand1 + operand2
• ADC
operand1 + operand2 + carry
• SUB
operand1 - operand2
• SBC
operand1 - operand2 + carry -1
• RSB
operand2 - operand1
• RSC
operand2 - operand1 + carry - 1
* Syntax:
• <Operation>{<cond>}{S} Rd, Rn, Operand2
* Examples
• ADD r0, r1, r2
• SUBGT r3, r3, #1
• RSBLES r4, r5, #5
RM Instruction Set - ARM University Program - V1.0
t
o
s
20
| Page 21 |
S
b
t
e
A
Th
Comparisons
* The only effect of the comparisons is to
• UPDATE THE CONDITION FLAGS. Thus no need to set
* Operations are:
• CMP
operand1 - operand2, but result not written
• CMN
operand1 + operand2, but result not written
• TST
operand1 AND operand2, but result not written
• TEQ
operand1 EOR operand2, but result not written
* Syntax:
• <Operation>{<cond>} Rn, Operand2
* Examples:
• CMP
r0, r1
• TSTEQ
r2, #5
RM Instruction Set - ARM University Program - V1.0
i
.
21
| Page 22 |
e
A
Th
Logical Operations
* Operations are:
• AND
operand1 AND operand2
• EOR
operand1 EOR operand2
• ORR
operand1 OR operand2
• BIC
operand1 AND NOT operand2 [ie bit clear]
* Syntax:
• <Operation>{<cond>}{S} Rd, Rn, Operand2
* Examples:
• AND
r0, r1, r2
• BICEQ
r2, r3, #7
• EORS
r1,r3,r0
RM Instruction Set - ARM University Program - V1.0
22
| Page 23 |
m
n
e
A
Th
Data Move
* Operations are:
• MOV
operand2
• MVN
NOT operand2
Note that these make no use of operand1.
* Syntax:
• <Operation>{<cond>}{S} Rd, Operand2
* Examples:
• MOV
r0, r1
• MOVS
r2, #10
• MVNEQ
r1,#0
RM Instruction Set - ARM University Program - V1.0
e
t
23
| Page 24 |
#
e
A
y
P
Th
Yes
r0 = r0 - r1
RM Instruction Set -
Start
r0 = r1
?
No
r0 > r1
?
ARM Universit
Quiz
Yes
Stop
No
r1 = r1 - r0
rogram - V1.0
2
*
*
Convert the GCD
algorithm given in this
flowchart into
1) “Normal” assembler,
where only branches can
be conditional.
2) ARM assembler, where
all instructions are
conditional, thus
improving code density.
The only instructions you
need are CMP, B and SUB.
24
| Page 25 |
n
e
A
M
n
u
o
Th
R
I
str
cti
Quiz #2 - Sample Solutio
“Normal” Assembler
gcd cmp r0, r1 ;reached the end?
beq stop
blt less ;if r0 > r1
sub r0, r0, r1 ;subtract r1 from r0
bal gcd
less sub r1, r1, r0 ;subtract r0 from r1
bal gcd
stop
ARM Conditional Assembler
gcd cmp r0, r1 ;if r0 > r1
subgt r0, r0, r1 ;subtract r1 from r0
sublt r1, r1, r0 ;else subtract r0 from r1
bne gcd ;reached the end?
n Set - ARM University Program - V1.0
s
25
| Page 26 |
The Barrel Shifter
* The ARM doesn’t have actual shift instructions.
* Instead it has a barrel shifter which provides a mechanism to carry out
shifts as part of other instructions.
* So what operations does the barrel shifter support?
The ARM Instruction Set - ARM University Program - V1.0
26
| Page 27 |
Barrel Shifter - Left Shift
* Shifts left by the specified amount (multiplies by powers of two) e.g.
LSL #5 = multiply by 32
Logical Shift Left (LSL)
CF
Destination
0
The ARM Instruction Set - ARM University Program - V1.0
27
| Page 28 |
e
A
Th
Barrel Shifter - Right Shifts
Logical Shift Right
Logical Shift Right
• Shifts right by the
specified amount
(divides by powers of
...0
Destination
two) e.g.
LSR #5 = divide by 32
Arithmetic Shift Right
Arithmetic Shift Right
• Shifts right (divides by
powers of two) and
preserves the sign bit,
Destination
for 2's complement
operations. e.g.
Sign bit shifted in
ASR #5 = divide by 32
RM Instruction Set - ARM University Program - V1.0
CF
CF
28
| Page 29 |
s
Barrel Shifter - Rotation
Rotate Right (ROR)
Rotate Right
• Similar to an ASR but the
b
l
e
i
t
a
s
v
w
e
r
h
t
a
p
e
L
a
r
S
o
B
u
n
a
d
n
d
a
s
a
p
t
h
p
e
e
y
a
r
a
s
D
e
s
t
i
n
a
t
i
o
n
the MSB.
e.g. ROR #5
• Note the last bit rotated is
also used as the Carry Out.
Rotate Right Extended (RRX)
Rotate Right through Carry
• This operation uses the
CPSR C flag as a 33rd bit.
• Rotates right by 1 bit.
Destination
Encoded as ROR #0.
The ARM Instruction Set - ARM University Program - V1.0
CF
CF
29
| Page 30 |
a
r
e
d
O
p
n
n
n
O
The ARM I
era
1
structio
Using the B
The Secon
d
Operand
2
Barrel
Shifter
ALU
Result
Set - ARM University Program - V1.0
r
*
*
*
l Shifter:
perand
Register, optionally with shift
operation applied.
Shift value can be either be:
• 5 bit unsigned integer
• Specified in bottom byte of
another register.
Immediate value
• 8 bit number
• Can be rotated right through
an even number of
positions.
• Assembler will calculate
rotate for you from
constant.
30
| Page 31 |
e
A
M
Th
R
Second Operand :
Shifted Register
* The amount by which the register is to be shifted is contained in
either:
• the immediate 5-bit field in the instruction
– NO OVERHEAD
– Shift is done for free - executes in single cycle.
• the bottom byte of a register (not PC)
– Then takes extra cycle to execute
– ARM doesn’ t have enough read ports to read 3 registers at
once.
– Then same as on other processors where shift is
separate instruction.
* If no shift is specified then a default shift is applied: LSL #0
• i.e. barrel shifter has no effect on value in register.
Instruction Set - ARM University Program - V1.0
31
| Page 32 |
n
n
I
*
*
*
*
The ARM
Second Operand :
Using a Shifted Register
Using a multiplication instruction to multiply by a constant means first
loading the constant into a register and then waiting a number of
internal cycles for the instruction to complete.
A more optimum solution can often be found by using some combinatio
of MOVs, ADDs, SUBs and RSBs with shifts.
• Multiplications by a constant equal to a ((power of 2) 1) can be done i
one cycle.
Example: r0 = r1 * 5
Example: r0 = r1 + (r1 * 4)
ï ADD r0, r1, r1, LSL #2
Example: r2 = r3 * 105
Example: r2 = r3 * 15 * 7
Example: r2 = r3 * (16 - 1) * (8 - 1)
ï RSB r2, r3, r3, LSL #4
; r2 = r3 * 15
ï RSB r2, r2, r2, LSL #3
; r2 = r2 * 7
nstruction Set - ARM University Program - V1.0
32
| Page 33 |
n
e
A
Th
Second Operand :
Immediate Value (1)
* There is no single instruction which will load a 32 bit immediate consta
into a register without performing a data load from memory.
• All ARM instructions are 32 bits long
• ARM instructions do not use the instruction stream as data.
* The data processing instruction format has 12 bits available for
operand2
• If used directly this would only give a range of 4096.
* Instead it is used to store 8 bit constants, giving a range of 0 - 255.
* These 8 bits can then be rotated right through an even number of
positions (ie RORs by 0, 2, 4,..30).
• This gives a much larger range of constants that can be directly loaded,
though some constants will still need to be loaded
from memory.
RM Instruction Set - ARM University Program - V1.0
t
33
| Page 34 |
6
6
I
*
*
*
*
*
The ARM
Second Operand :
Immediate Value (2)
This gives us:
• 0 - 255
[0 - 0xff]
• 256,260,264,..,1020
[0x100-0x3fc, step 4, 0x40-0xff ror 30]
• 1024,1040,1056,..,4080
[0x400-0xff0, step 16, 0x40-0xff ror 28]
• 4096,4160, 4224,..,16320
[0x1000-0x3fc0, step 64, 0x40-0xff ror 2
These can be loaded using, for example:
• MOV r0, #0x40, 26
; => MOV r0, #0x1000 (ie 4096)
To make this easier, the assembler will convert to this form for us if
simply given the required constant:
• MOV r0, #4096
; => MOV r0, #0x1000 (ie 0x40 ror 2
The bitwise complements can also be formed using MVN:
• MOV r0, #0xFFFFFFFF
; assembles to MVN r0, #0
If the required constant cannot be generated, an error will
be reported.
nstruction Set - ARM University Program - V1.0
]
)
34
| Page 35 |
e
A
Th
Loading full 32 bit constants
* Although the MOV/MVN mechansim will load a large range of constants
into a register, sometimes this mechansim will not generate the required
constant.
* Therefore, the assembler also provides a method which will load ANY 32
bit constant:
• LDR rd,=numeric constant
* If the constant can be constructed using either a MOV or MVN then this
will be the instruction actually generated.
* Otherwise, the assembler will produce an LDR instruction with a PC-
relative address to read the constant from a literal pool.
• LDR r0,=0x42
; generates MOV r0,#0x42
• LDR r0,=0x55555555 ; generate LDR r0,[pc, offset to lit pool]
* As this mechanism will always generate the best instruction for a given
case, it is the recommended way of loading constants.
RM Instruction Set - ARM University Program - V1.0
35
| Page 36 |
e
a
s
e
A
Th
Multiplication Instructions
* The Basic ARM provides two multiplication instructions.
* Multiply
• MUL{<cond>}{S} Rd, Rm, Rs
; Rd = Rm * Rs
* Multiply Accumulate
- does addition for free
• MLA{<cond>}{S} Rd, Rm, Rs,Rn
; Rd = (Rm * Rs) + Rn
* Restrictions on use:
• Rd and Rm cannot be the same register
– Can be avoid by swapping Rm and Rs around. This works b
multiplication is commutative.
• Cannot use PC.
These will be picked up by the assembler if overlooked.
* Operands can be considered signed or unsigned
• Up to user to interpret correctly.
RM Instruction Set - ARM University Program - V1.0
c
u
e
36
| Page 37 |
i
e
Multiplication Implementation
* The ARM makes use of Booth’s Algorithm to perform integer
multiplication.
* On non-M ARMs this operates on 2 bits of Rs at a time.
• For each pair of bits this takes 1 cycle (plus 1 cycle to start with).
• However when there are no more 1’ s left in Rs, the multiplication w
early-terminate.
* Example: Multiply 18 and -1 : Rd = Rm * Rs
Rm
18 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 18
Rs
-1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 -1
17 cycles
* Note: Compiler does not use early termination criteria to
decide on which order to place operands.
The ARM Instruction Set - ARM University Program - V1.0
ll
Rs
Rm
4 cycl
s
37
| Page 38 |
e
A
M
Th
R
Extended Multiply Instructions
* M variants of ARM cores contain extended multiplication
hardware. This provides three enhancements:
• An 8 bit Booth’s Algorithm is used
– Multiplication is carried out faster (maximum for standard
instructions is now 5 cycles).
• Early termination method improved so that now completes
multiplication when all remaining bit sets contain
– all zeroes (as with non-M ARMs), or
– all ones.
Thus the previous example would early terminate in 2 cycles in
both cases.
• 64 bit results can now be produced from two 32bit operands
– Higher accuracy.
– Pair of registers used to store result.
Instruction Set - ARM University Program - V1.0
38
| Page 39 |
e
A
Th
Multiply-Long and
Multiply-Accumulate Long
* Instructions are
• MULL which gives RdHi,RdLo:=Rm*Rs
• MLAL which gives RdHi,RdLo:=(Rm*Rs)+RdHi,RdLo
* However the full 64 bit of the result now matter (lower precision
multiply instructions simply throws top 32bits away)
• Need to specify whether operands are signed or unsigned
* Therefore syntax of new instructions are:
• UMULL{<cond>}{S} RdLo,RdHi,Rm,Rs
• UMLAL{<cond>}{S} RdLo,RdHi,Rm,Rs
• SMULL{<cond>}{S} RdLo, RdHi, Rm, Rs
• SMLAL{<cond>}{S} RdLo, RdHi, Rm, Rs
* Not generated by the compiler.
Warning : Unpredictable on non-M ARMs.
RM Instruction Set - ARM University Program - V1.0
39
| Page 40 |
#
e
A
Th
Quiz #3
1. Specify instructions which will implement the following:
a) r0 = 16
b) r1 = r0 * 4
c) r0 = r1 / 16 ( r1 signed 2's comp.)
d) r1 = r2 * 7
2. What will the following instructions do?
a) ADDS r0, r1, r1, LSL #2
b) RSB r2, r1,
3. What does the following instruction sequence do?
ADD r0, r1, r1, LSL #1
SUB r0, r0, r1, LSL #4
ADD r0, r0, r1, LSL #7
RM Instruction Set - ARM University Program - V1.0
0
40
| Page 41 |
e
A
M
Th
R
Load / Store Instructions
* The ARM is a Load / Store Architecture:
• Does not support memory to memory data processing operations.
• Must move data values into registers before using them.
* This might sound inefficient, but in practice isn’t:
• Load data values from memory into registers.
• Process data in registers using a number of data processing
instructions which are not slowed down by memory access.
• Store results from registers out to memory.
* The ARM has three sets of instructions which interact with main
memory. These are:
• Single register data transfer (LDR / STR).
• Block data transfer (LDM/STM).
• Single Data Swap (SWP).
Instruction Set - ARM University Program - V1.0
41
| Page 42 |
d
e
A
Th
Single register data transfer
* The basic load and store instructions are:
• Load and Store Word or Byte
– LDR / STR / LDRB / STRB
* ARM Architecture Version 4 also adds support for halfwords and signe
data.
• Load and Store Halfword
– LDRH / STRH
• Load Signed Byte or Halfword - load value and sign extend it to 32 bits.
– LDRSB / LDRSH
* All of these instructions can be conditionally executed by inserting the
appropriate condition code after STR / LDR.
• e.g. LDREQB
* Syntax:
• <LDR|STR>{<cond>}{<size>} Rd, <address>
RM Instruction Set - ARM University Program - V1.0
42
| Page 43 |
Load and Store Word or Byte:
Base Register
* The memory location to be accessed is held in a base register
• STR r0, [r1]
; Store contents of r0 to location pointed to
; by contents of r1.
• LDR r2, [r1]
; Load r2 with contents of memory location
; pointed to by contents of r1.
r0
Memory
S
R
o
e
g
u
i
r
s
c
t
e
e
r
0
x
5
for STR
Base
r1
r2
Destination
Register
0x200
0x200
0x5
0x5
Register
for LDR
The ARM Instruction Set - ARM University Program - V1.0
43
| Page 44 |
r
*
*
*
*
The ARM Inst
Load and Store Word or Byte:
Offsets from the Base Register
As well as accessing the actual location contained in the base register,
these instructions can access a location offset from the base register
pointer.
This offset can be
• An unsigned 12bit immediate value (ie 0 - 4095 bytes).
• A register, optionally shifted by an immediate value
This can be either added or subtracted from the base register:
• Prefix the offset value or register with ‘+’ (default) or ‘-’ .
This offset can be applied:
• before the transfer is made: Pre-indexed addressing
– optionally auto-incrementing the base register, by postfixing the
instruction with an ‘!’ .
• after the transfer is made: Post-indexed addressing
– causing the base register to be auto-incremented.
uction Set - ARM University Program - V1.0
44
| Page 45 |
e
Load and Store Word or Byt
Pre-indexed Addressing
* Example: STR r0, [r1,#12]
Memory
r0
0x5
Offset
12
0x20c
0x5
r1
R
B
e
a
g
i
s
s
e
t
e
r
0
x
2
0
0
0
x
2
0
0
* To store to location 0x1f4 instead use: STR r0, [r1,#-12]
* To auto-increment base pointer to 0x20c use: STR r0, [r1, #12]!
* If r2 contains 3, access 0x20c by multiplying this by 4:
• STR r0, [r1, r2, LSL #2]
The ARM Instruction Set - ARM University Program - V1.0
:
Source
Register
for STR
45
| Page 46 |
e
Th
Load and Store Word or Byte:
Post-indexed Addressing
* Example: STR r0, [r1], #12
Memory
Updated
r1
Offset
r0
Source
R
B
e
a
g
i
s
s
e
t
e
r
0
x
2
0
c
1
2
0
x
2
0
c
0
x
5
R
f
e
o
g
r
i
S
s
t
T
e
R
r
Original
r1
0x200
0x5
Base
0x200
Register
* To auto-increment the base register to location 0x1f4 instead use:
• STR r0, [r1], #-12
* If r2 contains 3, auto-incremenet base register to 0x20c by multiplying
this by 4:
• STR r0, [r1], r2, LSL #2
ARM Instruction Set - ARM University Program - V1.0
46
| Page 47 |
m
d
e
A
Th
Load and Stores
with User Mode Privilege
* When using post-indexed addressing, there is a further form of
Load/Store Word/Byte:
• <LDR|STR>{<cond>}{B}T Rd, <post_indexed_address>
* When used in a privileged mode, this does the load/store with user
privilege.
• Normally used by an exception handler that is emulating a memory
access instruction that would normally execute in user mode.
RM Instruction Set - ARM University Program - V1.0
o
e
47
| Page 48 |
e
o
e
I
*
*
*
The ARM
Example Usage of
Addressing Modes
Imagine an array, the first element of which is pointed to by the cont
of r0.
If we want to access a particular element,
element
then we can use pre-indexed addressing:
• r1 is element we want.
• LDR r2, [r0, r1, LSL #2]
3
Pointer to
2
If we want to step through every
start of array
1
element of the array, for instance
r0
0
to produce sum of elements in the
array, then we can use post-indexed addressing within a loop:
• r1 is address of current element (initially equal to r0).
• LDR r2, [r1], #4
Use a further register to store the address of final element,
so that the loop can be correctly terminated.
nstruction Set - ARM University Program - V1.0
nts
Mem
Offs
12
8
4
0
ry
t
48
| Page 49 |
h
e
A
Th
Offsets for Halfword and
Signed Halfword / Byte Access
* The Load and Store Halfword and Load Signed Byte or Halfword
instructions can make use of pre- and post-indexed addressing in muc
the same way as the basic load and store instructions.
* However the actual offset formats are more constrained:
• The immediate value is limited to 8 bits (rather than 12 bits) giving an
offset of 0-255 bytes.
• The register form cannot have a shift applied to it.
RM Instruction Set - ARM University Program - V1.0
49
| Page 50 |
d
e
A
M
Th
R
Effect of endianess
* The ARM can be set up to access its data in either little or big
endian format.
* Little endian:
• Least significant byte of a word is stored in bits 0-7 of an addresse
word.
* Big endian:
• Least significant byte of a word is stored in bits 24-31 of an
addressed word.
* This has no real relevance unless data is stored as words and then
accessed in smaller sized quantities (halfwords or bytes).
• Which byte / halfword is accessed will depend on the endianess of
the system involved.
Instruction Set - ARM University Program - V1.0
50
| Page 51 |
x
d
a
Endianess E
r0 = 0x11223344
31 24 23 16 15 8 7 0
11 22 33 44
STR r0, [r1]
31 24 23 16 15 8 7 0
r1 = 0x100
11 22 33 44
Memory
Little-endian
LDRB r2, [r1]
31 24 23 16 15 8 7 0
00 00 00 44
r2 = 0x44
The ARM Instruction Set - ARM University Program - V1.0
ample
31 24 23 16 15 8 7 0
44 33 22 11
31 24 23 16 15 8 7 0
00 00 00 11
r2 = 0x11
r1 = 0x100
Big-en
i
n
51
| Page 52 |
)
o
a
e
A
Th
Quiz #4
* Write a segment of code that add together elements x to x+(n-1
array, where the element x=0 is the first element of the array.
* Each element of the array is word sized (ie. 32 bits).
* The segment should use post-indexed addressing.
* At the start of your segments, you should assume that:
• r0 points to the start of the array.
Elements
• r1 = x
• r2 = n
x + (n - 1)
n
e
l
e
m
e
n
t
s
{
x
x
+
1
r0
0
RM Instruction Set - ARM University Program - V1.0
f
n
52
| Page 53 |
e
Th
Quiz #4 - Sample Solution
ADD r0, r0, r1, LSL#2
; Set r0 to address of element x
ADD r2, r0, r2, LSL#2
; Set r2 to address of element n+1
MOV r1, #0
; Initialise counter
loop
LDR r3, [r0], #4
; Access element and move to next
ADD r1, r1, r3
; Add contents to counter
CMP r0, r2
; Have we reached element x+n?
BLT loop
; If not - repeat for
;
next element
; on exit sum contained in r1
ARM Instruction Set - ARM University Program - V1.0
53
| Page 54 |
Block Data Transfer (1)
* The Load and Store Multiple instructions (LDM / STM) allow betweeen
1 and 16 registers to be transferred to or from memory.
* The transferred registers can be either:
• Any subset of the current bank of registers (default).
• Any subset of the user mode bank of registers when in a priviledged
mode (postfix instruction with a ‘^’ ).
31
28 27
24 23 22 21 20 19
16 15
0
Cond 1 0 0 P U S W L Rn
Register list
Condition field
Base register
Each bit corresponds to a particular
U
0
p
=
/
D
D
o
o
w
w
;
n
n
s
u
b
b
i
t
t
r
a
c
t
o
f
f
s
e
t
f
r
o
m
b
a
s
e
L
0
o
=
a
S
d
t
o
/
S
e
r
t
t
o
o
r
e
m
e
b
m
i
t
o
r
y
r
•
e
B
g
i
i
t
s
0
t
e
s
r
e
t
.
c
F
a
o
u
s
r
e
s
e
r
x
0
a
t
m
o
b
p
e
l
e
t
r
:
a
n
s
f
e
r
r
e
d
.
1
=
U
p
;
a
d
d
o
f
f
s
e
t
t
o
b
a
s
e
1
=
L
o
a
d
f
r
o
m
m
e
m
o
r
y
•
A
B
t
i
t
l
e
0
a
u
s
n
t
s
e
o
t
n
c
a
e
u
r
s
e
e
s
g
r
i
0
s
t
n
e
o
r
t
t
m
o
u
b
e
s
t
t
r
a
b
n
e
s
f
e
r
r
e
d
.
Pre/Post indexing bit
Write- back bit
transferred as the list cannot be empty.
0 = Post; add offset after transfer,
0 = no write-back
1 = Pre ; add offset before transfer
1 = write address into base
PSR and force user bit
0 = don’ t load PSR or force user mode
1 = load PSR or force user mode
The ARM Instruction Set - ARM University Program - V1.0
54
| Page 55 |
r
e
A
Th
Block Data Transfer (2)
* Base register used to determine where memory access should occur.
• 4 different addressing modes allow increment and decrement inclusive o
exclusive of the base register location.
• Base register can be optionally updated following the transfer (by
appending it with an ‘!’ .
• Lowest register number is always transferred to/from lowest memory
location accessed.
* These instructions are very efficient for
• Saving and restoring context
– For this useful to view memory as a stack.
• Moving large blocks of data around memory
– For this useful to directly represent functionality of the instructions.
RM Instruction Set - ARM University Program - V1.0
55
| Page 56 |
f
e
Th
Stacks
* A stack is an area of memory which grows as new data is “pushed” onto
the “top” of it, and shrinks as data is “popped” off the top.
* Two pointers define the current limits of the stack.
• A base pointer
– used to point to the “bottom” of the stack (the first location).
• A stack pointer
– used to point the current “top” of the stack.
PUSH
{1,2,3}
POP
SP
3
Result o
2
SP
2
pop = 3
1
1
B
S
A
P
S
E
B
A
S
E
B
A
S
E
ARM Instruction Set - ARM University Program - V1.0
56
| Page 57 |
e
A
Th
Stack Operation
* Traditionally, a stack grows down in memory, with the last “ pushed”
value at the lowest address. The ARM also supports ascending stacks,
where the stack structure grows up through memory.
* The value of the stack pointer can either:
• Point to the last occupied address (Full stack)
– and so needs pre-decrementing (ie before the push)
• Point to the next occupied address (Empty stack)
– and so needs post-decrementing (ie after the push)
* The stack type to be used is given by the postfix to the instruction:
• STMFD / LDMFD : Full Descending stack
• STMFA / LDMFA : Full Ascending stack.
• STMED / LDMED : Empty Descending stack
• STMEA / LDMEA : Empty Ascending stack
* Note: ARM Compiler will always use a Full descending stack.
RM Instruction Set - ARM University Program - V1.0
57
| Page 58 |
E
a
{
}
5
P
P
O
d
S
R
n
R
Old S
SP
The A
M I
STMFD sp!,
r0,r1,r3-r5
r5
r4
r3
r1
r0
struction Set - A
Stack
STMED sp!,
{r0,r1,r3-r5}
Old SP
r5
r4
r3
r1
r0
SP
M University Program - V1.0
x
SP
ld SP
mples
STMFA sp!,
{r0,r1,r3-r5}
r5
r4
r3
r1
r0
Ol
S
STMEA sp!,
{r0,r1,r3-r
r5
r4
r3
r1
P
r0
}
0x418
0x400
0x3e8
58
| Page 59 |
Stacks and Subroutines
* One use of stacks is to create temporary register workspace for
subroutines. Any registers that are needed can be pushed onto the stack
at the start of the subroutine and popped off again at the end so as to
restore them before return to the caller :
STMFD sp!,{r0-r12, lr}
; stack all registers
........
; and the return address
........
LDMFD sp!,{r0-r12, pc}
; load all the registers
; and return automatically
* See the chapter on the ARM Procedure Call Standard in the SDT
Reference Manual for further details of register usage within
subroutines.
* If the pop instruction also had the ‘S’ bit set (using ‘^’) then the transfer
of the PC when in a priviledged mode would also cause the SPSR to be
copied into the CPSR (see exception handling module).
The ARM Instruction Set - ARM University Program - V1.0
59
| Page 60 |
o
e
A
Th
Direct functionality of
Block Data Transfer
* When LDM / STM are not being used to implement stacks, it is clearer t
specify exactly what functionality of the instruction is:
• i.e. specify whether to increment / decrement the base pointer, before or
after the memory access.
* In order to do this, LDM / STM support a further syntax in addition to
the stack one:
• STMIA / LDMIA : Increment After
• STMIB / LDMIB : Increment Before
• STMDA / LDMDA : Decrement After
• STMDB / LDMDB : Decrement Before
RM Instruction Set - ARM University Program - V1.0
60
| Page 61 |
4
Example: Block Copy
• Copy a block of memory, which is an exact multiple of 12 words long
from the location pointed to by r12 to the location pointed to by r13. r1
points to the end of block to be copied.
; r12 points to the start of the source data
; r14 points to the end of the source data
; r13 points to the start of the destination data
loop LDMIA r12!, {r0-r11} ; load 48 bytes
r13
STMIA r13!, {r0-r11} ; and store them
r14
CMP
r12, r14
; check for the end
BNE
loop
; and loop until done
• This loop transfers 48 bytes in 31 cycles
r12
• Over 50 Mbytes/sec at 33 MHz
The ARM Instruction Set - ARM University Program - V1.0
Increasing
Memory
61
| Page 62 |
t
e
A
Th
Quiz #5
* The contents of registers r0 to r6 need to be swapped around thus:
• r0 moved into r3
• r1 moved into r4
• r2 moved into r6
• r3 moved into r5
• r4 moved into r0
• r5 moved into r1
• r6 moved into r2
* Write a segment of code that uses full descending stack operations
carry this out, and hence requires no use of any other registers for
temporary storage.
RM Instruction Set - ARM University Program - V1.0
o
62
| Page 63 |
m
p
o
u
i
n
Old SP
SP
The ARM I
Quiz #5 - Sa
STMFD sp!,
LDMFD sp!,
{r0-r6}
{r3,r4,r6}
r6
r6
r5
r5
r4
r4
r3
SP
r3
r2
r1
r0
r3 = r0
r4 = r1
r6 = r2
struction Set - ARM University Program - V1.0
SP
le S
LDMFD sp!,
{r5}
r6
r5
r4
r5 = r3
l
t
SP
on
LDMFD sp!,
{r0-r2}
r0 = r4
r1 = r5
r2 = r6
63
| Page 64 |
t
e
A
M
n
Th
R
I
Swap and Swap Byte
Instructions
* Atomic operation of a memory read followed by a memory wri
which moves byte or word quantities between registers and
memory.
* Syntax:
• SWP{<cond>}{B} Rd, Rm, [Rn]
1
Rn
temp
2
3
Memory
Rm
Rd
* Thus to implement an actual swap of contents make Rd = Rm.
* The compiler cannot produce this instruction.
struction Set - ARM University Program - V1.0
e
64
| Page 65 |
g
e
A
Th
Software Interrupt (SWI)
31
28 27
24 23
0
Cond 1 1 1 1
Comment field (ignored by Processor)
Condition Field
* In effect, a SWI is a user-defined instruction.
* It causes an exception trap to the SWI hardware vector (thus causing a
change to supervisor mode, plus the associated state saving), thus causin
the SWI exception handler to be called.
* The handler can then examine the comment field of the instruction to
decide what operation has been requested.
* By making use of the SWI mechansim, an operating system can
implement a set of privileged operations which applications running in
user mode can request.
* See Exception Handling Module for further details.
RM Instruction Set - ARM University Program - V1.0
65
| Page 66 |
f
o
e
A
Th
PSR Transfer Instructions
* MRS and MSR allow contents of CPSR/SPSR to be transferred
appropriate status register to a general purpose register.
• All of status register, or just the flags, can be transferred.
* Syntax:
• MRS{<cond>} Rd,<psr>
; Rd = <psr>
• MSR{<cond>} <psr>,Rm
; <psr> = Rm
• MSR{<cond>} <psrf>,Rm
; <psrf> = Rm
where
• <psr> = CPSR, CPSR_all, SPSR or SPSR_all
• <psrf> = CPSR_flg or SPSR_flg
* Also an immediate form
• MSR{<cond>} <psrf>,#Immediate
• This immediate must be a 32-bit immediate, of which the 4
most significant bits are written to the flag bits.
RM Instruction Set - ARM University Program - V1.0
r
m
66
| Page 67 |
n
e
A
Th
Using MRS and MSR
* Currently reserved bits, may be used in future, therefore:
• they must be preserved when altering PSR
• the value they return must not be relied upon when testing other bits.
31
28
8
4
0
N Z C V
I F T
Mode
* Thus read-modify-write strategy must be followed when modifying a
PSR:
• Transfer PSR to register using MRS
• Modify relevant bits
• Transfer updated value back to PSR using MSR
* Note:
• In User Mode, all bits can be read but only the flag bits can
be written to.
RM Instruction Set - ARM University Program - V1.0
y
67
| Page 68 |
e
A
Th
Coprocessors
* The ARM architecture supports 16 coprocessors
* Each coprocessor instruction set occupies part of the ARM instruction
set.
* There are three types of coprocessor instruction
• Coprocessor data processing
• Coprocessor (to/from ARM) register transfers
• Coprocessor memory transfers (load and store to/from memory)
* Assembler macros can be used to transform custom coprocessor
mneumonics into the generic mneumonics understood by the processor.
* A coprocessor may be implemented
• in hardware
• in software (via the undefined instruction exception)
• in both (common cases in hardware, the rest in software)
RM Instruction Set - ARM University Program - V1.0
68
| Page 69 |
f
e
A
Th
Coprocessor Data Processing
* This instruction initiates a coprocessor operation
* The operation is performed only on internal coprocessor state
• For example, a Floating point multiply, which multiplies the contents o
two registers and stores the result in a third register
* Syntax:
• CDP{<cond>} <cp_num>,<opc_1>,CRd,CRn,CRm,{<opc_2>}
31 28 27 26 25 24 23 20 19 16 15 12 11 8 7 5 4 3 0
Cond 1 1 1 0 opc_1 CRn CRd cp_num opc_2 0 CRm
Destination Register
Opcode
Source Registers
Opcode
Condition Code Specifier
RM Instruction Set - ARM University Program - V1.0
69
| Page 70 |
*
*
*
The ARM
Coprocessor Register
Transfers
These two instructions move data between ARM registers and
coprocessor registers
• MRC : Move to Register from Coprocessor
• MCR : Move to Coprocessor from Register
An operation may also be performed on the data as it is transferred
• For example a Floating Point Convert to Integer instruction can be
implemented as a register transfer to ARM that also converts the data
from floating point format to integer format.
Syntax
• <MRC|MCR>{<cond>} <cp_num>,<opc_1>,Rd,CRn,CRm,<opc_2>
31 28 27 26 25 24 23 22 21 20 19 16 15 12 11
8 7 5 4 3 0
Cond 1 1 1 0 opc_1 L CRn Rd cp_num opc_2 1 CRm
ARM Source/Dest Register
Opcode
Coprocesor Source/Dest Registers
Condition Code Specifier
Transfer To/From Coprocessor
Opcode
Instruction Set - ARM University Program - V1.0
70
| Page 71 |
0
e
Th
Coprocessor Memory
Transfers (1)
* Load from memory to coprocessor registers
* Store to memory from coprocessor registers.
31 28 27 26 25 24 23 22 21 20 19 16 15 12 11
8 7
Cond 1 1 0 P U N W L Rn CRd cp_num Offset
Source/Dest Register
Address Offset
Base Register
Load/Store
Condition Code Specifier
Base Register Writeback
Transfer Length
Add/Subtract Offset
Pre/Post Increment
ARM Instruction Set - ARM University Program - V1.0
71
| Page 72 |
e
A
Th
Coprocessor Memory
Transfers (2)
* Syntax of these is similar to word transfers between ARM and memory:
• <LDC|STC>{<cond>}{<L>} <cp_num>,CRd,<address>
– PC relative offset generated if possible, else causes an error.
• <LDC|STC>{<cond>}{<L>} <cp_num>,CRd,<[Rn,offset]{!}>
– Pre-indexed form, with optional writeback of the base register
• <LDC|STC>{<cond>}{<L>} <cp_num>,CRd,<[Rn],offset>
– Post-indexed form
where
• <L> when present causes a “ long” transfer to be performed (N=1) else
causes a “ short” transfer to be performed (N=0).
– Effect of this is coprocessor dependant.
RM Instruction Set - ARM University Program - V1.0
72
| Page 73 |
e
A
Th
Quiz #6
* Write a short code segment that performs a mode change by modifying
the contents of the CPSR
• The mode you should change to is user mode which has the value 0x10.
• This assumes that the current mode is a priveleged mode such as
supervisor mode.
• This would happen for instance when the processor is reset - reset code
would be run in supervisor mode which would then need to switch to
user mode before calling the main routine in your application.
• You will need to use MSR and MRS, plus 2 logical operations.
31
28
8
4
0
N Z C V
I F T
Mode
RM Instruction Set - ARM University Program - V1.0
73
| Page 74 |
e
A
Th
Quiz #6 - Sample Solution
* Set up useful constants:
mmask EQU 0x1f
; mask to clear mode bits
userm EQU 0x10
; user mode value
* Start off here in supervisor mode.
MRS r0, cpsr
; take a copy of the CPSR
BIC r0,r0,#mmask ; clear the mode bits
ORR r0,r0,#userm ; select new mode
MSR cpsr, r0
; write back the modified
; CPSR
* End up here in user mode.
RM Instruction Set - ARM University Program - V1.0
74
| Page 75 |
g
e
A
Th
Main features of the
ARM Instruction Set
* All instructions are 32 bits long.
* Most instructions execute in a single cycle.
* Every instruction can be conditionally executed.
* A load/store architecture
• Data processing instructions act only on registers
– Three operand format
– Combined ALU and shifter for high speed bit manipulation
• Specific memory access instructions with powerful auto-indexin
addressing modes.
– 32 bit and 8 bit data types
and also 16 bit data types on ARM Architecture v4.
– Flexible multiple register load and store instructions
* Instruction set extension via coprocessors
RM Instruction Set - ARM University Program - V1.0
75