ARM Assembler Addressing Modes Addressing Modes p. 1/14 op1 : - PowerPoint PPT Presentation

Systems Architecture ARM Assembler Addressing Modes Addressing Modes – p. 1/14

� op1 � : Data Addressing Mode Used when processing data Moving data from one register to another: • D ESTINATION ← − S OURCE D ESTINATION must be a register S OURCE can be any � op1 � value MOV r0, r1 R 0 ← R 1 Performing an operation on data: • D ESTINATION ← − S OURCE 1 O PERATION S OURCE 2 D ESTINATION and S OURCE 1 must be registers S OURCE 2 can be any � op1 � value ADD r0, r1, r2 R 0 ← R 0 + R 2 SUB r0, r1, #1 R 0 ← R 0 − 1 AND r0, r0, r1 R 0 ← R 0 ∧ R 1 Addressing Modes – p. 2/14

Data Processing Four possible values for � op1 � : • # nnn Immediate R n Register R n , � shift � # nnn Scaled Immediate R n , � shift � R s Scaled Register Possible values of � shift � : • LSL Logical Shift Left LSR Logical Shift Right ASR Arithmetic Shift Right ROR Rotate Right RRX Rotate Right eXtended Addressing Modes – p. 3/14

Immediate Also known as literal addressing • Constant value incorporated into instruction: • � op1 � ← IR(value) MOV r0, #12 ALU ← � op1 � R 0 ← ALU Range of valid immediate values: • 0 through to 255 or 0x00 through to 0xFF The immediate value can be rotated right: • � op1 � ← IR(value) > MOV r0, #0x12, 8 > IR(shift) > ALU ← � op1 � R 0 ← ALU Will move 0x12000000 into register R 0 use 16 to move 0x00120000 use 24 to move 0x00001200 Addressing Modes – p. 4/14

Register Data is held in a register, • , LR, or PC, but not CPSR R 0 – R 12 , SP � op1 � ← R 1 MOV r0, r1 ALU ← � op1 � R 0 ← ALU Accessing CPSR is a Privileged Instruction • Register for current mode is used unless a • mode is given and in a privileged mode: MOV r0, r14_usr Addressing Modes – p. 5/14

Scaled Values Data is held in a register • Value is scaled according to a shift type: • LSL Logical Shift Left ( < < ) LSR Logical Shift Right ( > > ) ASR Arithmetic Shift Right ( + > ) > ROR Rotate Right ( > > ) > RRX Rotate Right eXtended (C > > ) > Shift value give in two ways: • Immediate : By a specified amount: ⇒ � op1 � ← R 1 < r1, LSL #8 . . . < IR(shift) Register : Shift value stored in a register: ⇒ � op1 � ← R 1 < r1, LSL r2 . . . < R 2 Addressing Modes – p. 6/14

Shift Types (1/2) LSL : Logical Shift Left ( < < ) • Signed or Unsigned multiply by 2 n C Register 0 LSR : Logical Shift Right ( > > ) • Unsigned divide by 2 n C 0 Register ASR : Arithmetic Shift Right ( + > ) • > Signed divide by 2 n MSB Register C Addressing Modes – p. 7/14

Shift Types (2/2) ROR : Rotate Right ( > > ) • > Register C RRX : Rotate Right Extended (C > > ) • > Can only move one bit, no shift value allowed Used for multi-word rotates C C Register Addressing Modes – p. 8/14

� op2 � : Memory Addressing Mode Used when accessing memory Reading (Loading) data from memory: • D ESTINATION ← − M(S OURCE ) D ESTINATION must be a register S OURCE is any � op2 � value LDR r1, [r12] R 1 ← M(R 12 ) Writing (Storing) data into memory • M(D ESTINATION ) ← − S OURCE S OURCE must be a register D ESTINATION is any � op2 � value STR r1, [r12] M(R 12 ) ← R 1 Store is the only ARM instruction to place the S OURCE before the D ESTINATION Addressing Modes – p. 9/14

Memory Addressing (Syntax) Offset Addressing • [R n , # � value � ] Offset Immediate [R n , R m ] Offset Register [R n , R m , � shift � # � value � ] Offset scaled Pre-Index Addressing • [R n , # � value � ]! Pre-Index Immediate [R n , R m ]! Pre-Index Register [R n , R m , � shift � # � value � ]! Pre-Index scaled Post-Index Addressing • [R n ], # � value � Post-Index Immediate [R n ], R m Post-Index Register [R n ], R m , � shift � # � value � Post-Index scaled Addressing Modes – p. 10/14

Memory Addressing (RTL) Offset Addressing: LDR R0, [R1, R2] • � op2 � R 1 + R 2 ← M( � op2 � ) MBR ← R0 MBR ← Pre-Index Addressing: LDR R0, [R1, R2]! • � op2 � R 1 + R 2 ← � op2 � R 1 ← M( � op2 � ) MBR ← R0 MBR ← Post-Index Addressing: LDR R0, [R1], R2 • � op2 � R 1 ← R 1 R 1 + R 2 ← M( � op2 � ) MBR ← R0 MBR ← Addressing Modes – p. 11/14

Memory Addressing (RTL) Offset Addressing: LDR R0, [R1, R2] • � op2 � R 1 + R 2 ← LDR R0, [R1, x ] M( � op2 � ) MBR ← R0 R1 + R0 MBR ← Pre-Index Addressing: LDR R0, [R1, R2]! • � op2 � R 1 + R 2 ← � op2 � R 1 ← M( � op2 � ) MBR ← R0 MBR ← Post-Index Addressing: LDR R0, [R1], R2 • � op2 � R 1 ← R 1 R 1 + R 2 ← M( � op2 � ) MBR ← R0 MBR ← Addressing Modes – p. 11/14

Memory Addressing (RTL) Offset Addressing: LDR R0, [R1, R2] • � op2 � R 1 + R 2 ← LDR R0, [R1, x ] M( � op2 � ) MBR ← R0 R1 + R0 MBR ← Pre-Index Addressing: LDR R0, [R1, R2]! • � op2 � R 1 + R 2 ← LDR R0, [R1, x ]! � op2 � R 1 ← R0 R1 + M( � op2 � ) MBR ← R0 MBR ← Post-Index Addressing: LDR R0, [R1], R2 • � op2 � R 1 ← R 1 R 1 + R 2 ← M( � op2 � ) MBR ← R0 MBR ← Addressing Modes – p. 11/14

Memory Addressing (RTL) Offset Addressing: LDR R0, [R1, R2] • � op2 � R 1 + R 2 ← LDR R0, [R1, x ] M( � op2 � ) MBR ← R0 R1 + R0 MBR ← Pre-Index Addressing: LDR R0, [R1, R2]! • � op2 � R 1 + R 2 ← LDR R0, [R1, x ]! � op2 � R 1 ← R0 R1 + M( � op2 � ) MBR ← R0 MBR ← Post-Index Addressing: LDR R0, [R1], R2 • � op2 � R 1 ← LDR R0, [R1], x R 1 R 1 + R 2 ← R0 R1 + M( � op2 � ) MBR ← R0 MBR ← Addressing Modes – p. 11/14

Offset Addressing [R n , # � value � ] Offset Immediate [R n , R m ] Offset Register [R n , R m , � shift � # � value � ] Offset scaled Calculate address by adding offset to base register R n • � op2 � Immediate: R n + IR(value) ← � op2 � Register: R n + R m ← � op2 � R n + R m � shift � IR(value) Scaled: ← Read data from calculated memory address • � op2 � MAR ← MBR M(MAR) ← ALU MBR ← Addressing Modes – p. 12/14

Pre-Index Addressing [R n , # � value � ]! Pre-Index Immediate [R n , R m ]! Pre-Index Register [R n , R m , � shift � # � value � ]! Pre-Index scaled Calculate address by adding offset to base register R n • � op2 � Immediate: R n + IR(value) ← � op2 � Register: R n + R m ← � op2 � R n + R m � shift � IR(value) Scaled: ← Write the address back into the base register (!) • � op2 � R n ← Read data from calculated memory address • � op2 � MAR ← MBR M(MAR) ← ALU MBR ← Addressing Modes – p. 13/14

Post-Index Addressing [R n ], # � value � Post-Index Immediate [R n ], R m Post-Index Register [R n ], R m , � shift � # � value � Post-Index scaled Address contained in the base register R n • � op2 � R n ← Increment base register (R n ) • Immediate: R n R n + IR(value) ← Register: R n R n + R m ← R n + R m � shift � IR(value) Scaled: R n ← Read data address in base register • � op2 � MAR ← MBR M(MAR) ← ALU MBR ← Addressing Modes – p. 14/14