Architecture Revisions

version ARMv7 ARM1156T2F-S ARM1136JF-S ARMv6 ARM102xE XScaleTM ARMv5

ARM7TDMI-S StrongARM

ARM1176JZF-S ARM1026EJ-S

ARM9x6E ARM926EJ-S SC200 ARM92xT

V4 SC100 ARM720T

1994

1996

1998

2000

2002

2004

2006 time

XScale is a trademark of Intel Corporation

1

Data Sizes and Instruction Sets

The ARM is a 32-bit architecture. When used in relation to the ARM: Byte means 8 bits Halfword means 16 bits (two bytes) Word means 32 bits (four bytes) Most ARMs implement two instruction sets 32-bit ARM Instruction Set 16-bit Thumb Instruction Set Jazelle cores can also execute Java bytecode

Processor Modes

The ARM has seven basic 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 instruction is executed Abort : used to handle memory access violations Undef : used to handle undefined instructions System : privileged mode using the same registers as user mode
3

The ARM Register Set

Current Visible Registers
Abort Undef Mode SVC Mode IRQ Mode FIQ Mode User Mode
r0 r1 r2 r3 r4 r5 r6

Banked out Registers

User
r8 r9 r10 r11 r12 r13 (sp) r14 (lr)

FIQ
r8 r9 r10 r11 r12 r13 (sp) r14 (lr)

IRQ

SVC

Undef

Abort

r7 r8 r9 r10 r11 r12 r13 (sp) r14 (lr) r15 (pc)

cpsr spsr

r13 (sp) r14 (lr)

r13 (sp) r14 (lr)

r13 (sp) r14 (lr)

r13 (sp) r14 (lr)

spsr

spsr

spsr

spsr

spsr

Exception Handling

When an exception occurs, the ARM: Copies CPSR into SPSR_<mode> Sets appropriate CPSR bits 0x1C Change to ARM state 0x18 Change to exception mode 0x14 Disable interrupts (if appropriate) 0x10 Stores the return address in LR_<mode> 0x0C 0x08 Sets PC to vector address 0x04 To return, exception handler needs to:0x00 Restore CPSR from SPSR_<mode> Restore PC from LR_<mode> This can only be done in ARM state.

FIQ IRQ (Reserved) Data Abort Prefetch Abort

Software Interrupt Undefined Instruction

Reset

Vector Table
Vector table can be at 0xFFFF0000 on ARM720T and on ARM9/10 family devices

Program Status Registers

31 28 27 24 23 16 15 8 7 6 5 4 0

N Z C V Q f

n s

e x

I F T c

mode

Condition code flags

N = Negative result from ALU Z = Zero result from ALU C = ALU operation Carried out V = ALU operation oVerflowed

Interrupt Disable bits.

I = 1: Disables the IRQ. F = 1: Disables the FIQ.

T Bit
Architecture xT only T = 0: Processor in ARM state T = 1: Processor in Thumb state

Sticky Overflow flag - Q flag

Architecture 5TE/J only Indicates if saturation has occurred

Mode bits J bit

Architecture 5TEJ only J = 1: Processor in Jazelle state
Specify the processor mode

039v12

Program Counter (r15)

When the processor is executing in ARM state:

All instructions are 32 bits wide All instructions must be word aligned Therefore the pc value is stored in bits [31:2] with bits [1:0] undefined (as instruction
cannot be halfword or byte aligned)

When the processor is executing in Thumb state:

All instructions are 16 bits wide All instructions must be halfword aligned Therefore the pc value is stored in bits [31:1] with bit [0] undefined (as instruction
cannot be byte aligned)

When the processor is executing in Jazelle state:

All instructions are 8 bits wide Processor performs a word access to read 4 instructions at once
039v12 7

Conditional Execution and Flags

ARM instructions can be made to execute conditionally by postfixing them with the appropriate condition code field. This improves code density and performance by reducing the number of forward branch instructions. CMP r3,#0 CMP r3,#0 BEQ skip ADDNE r0,r1,r2 ADD r0,r1,r2 skip By default, data processing instructions do not affect the condition code flags but the flags can be optionally set by using S. CMP does not need S. loop decrement r1 and set flags SUBS r1,r1,#1 BNE loop if Z flag clear then branch

Condition Codes
The possible condition codes are listed below
Note AL is the default and does not need to be specified
Suffix

EQ NE CS/HS CC/LO MI PL VS VC HI LS GE LT GT LE AL

Description Equal Not equal Unsigned higher or same Unsigned lower Minus Positive or Zero Overflow No overflow Unsigned higher Unsigned lower or same Greater or equal Less than Greater than Less than or equal Always

Flags tested Z=1 Z=0 C=1 C=0 N=1 N=0 V=1 V=0 C=1 & Z=0 C=0 or Z=1 N=V N!=V Z=0 & N=V Z=1 or N=!V

Conditional execution examples

C source code if (r0 == 0) { r1 = r1 + 1; } else { r2 = r2 + 1; } ARM instructions unconditional conditional CMP r0, #0 CMP r0, #0 BNE else ADDEQ r1, r1, #1 ADD r1, r1, #1 ADDNE r2, r2, #1 B end ... else ADD r2, r2, #1 end ... 5 instructions 5 words 5 or 6 cycles 3 instructions 3 words 3 cycles

10

Data Processing Instructions

Consist of : Arithmetic: Logical: Comparisons: Data movement:
ADD AND CMP MOV ADC ORR CMN MVN SUB EOR TST SBC BIC TEQ RSB RSC

These instructions only work on registers, NOT memory. Syntax:

<Operation>{<cond>}{S} Rd, Rn, Operand2

Comparisons set flags only - they do not specify Rd Data movement does not specify Rn Second operand is sent to the ALU via barrel shifter.
11

Using a Barrel Shifter:The 2nd Operand

Operand 1
Operand 2
Register, optionally with shift operation Shift value can be either be: 5 bit unsigned integer Specified in bottom byte of another register. Used for multiplication by constant Immediate value 8 bit number, with a range of 0255. Rotated right through even number of positions Allows increased range of 32-bit constants to be loaded directly into registers
12

Barrel Shifter

ALU

Result

Data Processing Exercise

1. How would you load the twos complement representation of -1 into Register 3 using one instruction?

2. Implement an ABS (absolute value) function for a registered value using only two instructions. 3. Multiply a number by 35, guaranteeing that it executes in 2 core clock cycles.

13

Data Processing Solutions

1. MOVN 2. MOVS RSBMI 3. ADD RSB r6, #0 r7,r7 r7,r7,#0 ; set the flags ; if neg, r7=0-r7 ; r9=r8*5 ; r10=r9*7

r9,r8,r8,LSL #2 r10,r9,r9,LSL #3

14

Immediate constants

No ARM instruction can contain a 32 bit immediate constant All ARM instructions are fixed as 32 bits long The data processing instruction format has 12 bits available for operand2
11 rot 8 7 immed_8 0

Quick Quiz:

x2

Shifter ROR

0xe3a004ff MOV r0, #???

4 bit rotate value (0-15) is multiplied by two to give range 030 in steps of 2 8-bits rotated right by an even number of bit positions
15

Rule to remember is

Loading 32 bit constants

To allow larger constants to be loaded, the assembler offers a pseudo
instruction: LDR rd, =const This will either: Produce a MOV or MVN instruction to generate the value (if possible). or Generate a LDR instruction with a PC-relative address to read the constant from a literal pool (Constant data area embedded in the code). For example MOV r0,#0xFF => LDR r0,=0xFF LDR r0,[PC,#Imm12] LDR r0,=0x55555555 => DCD 0x55555555 This is the recommended way of loading constants into a register

16

Single register data transfer

LDR

LDRB LDRH LDRSB LDRSH

STR Word STRB Byte STRH Halfword Signed byte load Signed halfword load

Memory system must support all access sizes

Syntax:
LDR{<cond>}{<size>} Rd, <address> STR{<cond>}{<size>} Rd, <address>
e.g. LDREQB
17

Address accessed

Address accessed by LDR/STR is specified by a base register with an offset

For word and unsigned byte accesses, offset can be:

An unsigned 12-bit immediate value (i.e. 0 - 4095 bytes) LDR r0, [r1, #8] A register, optionally shifted by an immediate value LDR r0, [r1, r2] LDR r0, [r1, r2, LSL#2]

This can be either added or subtracted from the base register: LDR r0, [r1, #-8] LDR r0, [r1, -r2, LSL#2] For halfword and signed halfword / byte, offset can be:

An unsigned 8 bit immediate value (i.e. 0 - 255 bytes)

A register (unshifted)

Choice of pre-indexed or post-indexed addressing Choice of whether to update the base pointer (pre-indexed only) LDR r0, [r1, #-8]!

18

Load/Store Exercise
Assume an array of 25 words. A compiler associates y with r1. Assume that the base address for the array is located in r2. Translate this C statement/assignment using just three instructions:

array[10] = array[5] + y;

19

Load/Store Exercise Solution

array[10] = array[5] + y;

LDR

r3, [r2, #5]

; r3 = array[5]

ADD r3, r3, r1 STR r3, [r2, #10] array[10]

; r3 = array[5] + y ; array[5] + y =

20

Load and Store Multiples

Syntax: <LDM|STM>{<cond>}<addressing_mode> Rb{!}, <register list> 4 addressing modes: increment after LDMIA / STMIA increment before LDMIB / STMIB LDMDA / STMDA decrement after LDMDB / STMDB decrement before DA IA IB DB
r4 r4 r1 r0 r1 r0 r4 r1 r0 r4 r1

LDMxx r10, {r0,r1,r4} STMxx r10, {r0,r1,r4}

Base Register (Rb) r10

Increasing Address

r0

21

Multiply and Divide

There are 2 classes of multiply - producing 32-bit and 64-bit results 32-bit versions on an ARM7TDMI will execute in 2 - 5 cycles

MUL r0, r1, r2 MLA r0, r1, r2, r3

; r0 = r1 * r2 ; r0 = (r1 * r2) + r3

64-bit multiply instructions offer both signed and unsigned versions For these instruction there are 2 destination registers

[U|S]MULL r4, r5, r2, r3 ; r5:r4 = r2 * r3 [U|S]MLAL r4, r5, r2, r3 ; r5:r4 = (r2 * r3) + r5:r4

Most ARM cores do not offer integer divide instructions Division operations will be performed by C library routines or inline shifts

22

Branch instructions
B{<cond>} label Branch : Branch with Link : BL{<cond>} subroutine_label

31

28 27

25 24 23

Cond

1 0 1 L

Offset

Link bit

0 = Branch 1 = Branch with link

Condition field

The processor core shifts the offset field left by 2 positions, sign-extends it
and adds it to the PC 32 Mbyte range How to perform longer branches?

23

Register Usage
Register

Arguments into function Result(s) from function otherwise corruptible (Additional parameters
passed on stack)

r0 r1 r2 r3

The compiler has a set of rules known as a Procedure Call Standard that determine how to pass parameters to a function (see AAPCS) CPSR flags may be corrupted by function call. Assembler code which links with compiled code must follow the AAPCS at external interfaces The AAPCS is part of the new ABI for the ARM Architecture
- Stack base - Stack limit if software stack checking selected

Register variables Must be preserved

r4 r5 r6 r7 r8 r9/sb r10/sl r11

Scratch register (corruptible) Stack Pointer Link Register Program Counter

r12
r13/sp r14/lr r15/pc

- SP should always be 8-byte (2 word) aligned - R14 can be used as a temporary once value stacked

24

ARM Branches and Subroutines

B <label>

PC relative. 32 Mbyte range.

BL <subroutine>

Stores return address in LR Returning implemented by restoring the PC from LR For non-leaf functions, LR will have to be stacked
func1
: : BL func1 : :

func2
: : : :

STMFD sp!,{regs,lr}
: BL func2 : LDMFD sp!,{regs,pc}

:
MOV pc, lr

039v12

25

PSR access
31 28 27 24 23 19 16 15 10 9 8 7 6 5 4 0

N Z C V Q de f

J s

GE[3:0] IT cond_abc E A I F T x c

mode

MRS and MSR allow contents of CPSR / SPSR to be transferred to / from a general purpose register or take an immediate value MSR allows the whole status register, or just parts of it to be updated Interrupts can be enable/disabled and modes changed, by writing to the CPSR Typically a read/modify/write strategy should be used: MRS r0,CPSR BIC r0,r0,#0x80 MSR CPSR_c,r0 ; read CPSR into r0 ; clear bit 7 to enable IRQ ; write modified value to c byte only

In User Mode, all bits can be read but only the condition flags (_f) can be modified

26

Agenda
Introduction to ARM Ltd

Fundamentals, Programmers Model, and Instructions Core Family Pipelines AMBA

27

Pipeline changes for ARM9TDMI

ARM7TDMI
Instruction Fetch ThumbARM decompress ARM decode Reg Select Reg Read Shift ALU Reg Write

FETCH

DECODE

EXECUTE

ARM9TDMI
Instruction Fetch ARM or Thumb Inst Decode Reg Reg Decode Read Shift + ALU Memory Access Reg Write

FETCH

DECODE

EXECUTE

MEMORY

WRITE

28

ARM10 vs. ARM11 Pipelines

ARM10
Branch Prediction Instruction Fetch ARM or Thumb Instruction Decode Reg Read Shift + ALU Memory Access Multiply Add Reg Write

Multiply

FETCH

ISSUE

DECODE

EXECUTE

MEMORY

WRITE

ARM11
Shift ALU Saturate

Fetch 1

Fetch 2

Decode

Issue

MAC 1

MAC 2 Data Cache 1

MAC 3 Data Cache 2

Write back

Address

29

Agenda
Introduction to ARM Ltd

Fundamentals, Programmers Model, and Instructions Core Family Pipelines AMBA

30

Example ARM-based System

16 bit RAM

32 bit RAM

Interrupt Controller
nIRQ nFIQ

Peripherals

I/O

8 bit ROM

ARM Core

039v12

31

An Example AMBA System

High Performance ARM processor High Bandwidth External Memory Interface High-bandwidth on-chip RAM APB UART Timer APB Bridge Keypad PIO

AHB

DMA Bus Master

High Performance Pipelined Burst Support Multiple Bus Masters

Low Power Non-pipelined Simple Interface

039v12

32

AHB Structure
Arbiter
HADDR HWDATA HRDATA HRDATA

Master #1

HADDR HWDATA

Slave #1

Address/Control

Master #2
Write Data Read Data

Slave #2

Slave #3

Master #3 Slave #4 Decoder

039v12

33