4.6.3.1 Operand Syntaxes for Instructions

The assembler allows you to specify that an operand should be used as an address, an immediate value, an indirect address, a register, a shifted register, or a register list. The following rules apply to the operands of instructions.

• # prefix — the operand is an immediate value. Using the # sign as a prefix causes the assembler to treat the operand as an immediate value. This is true even if the operand is a register; the assembler treats the register as a value instead of using the contents of the register. For example:
Label: ADD R1, R1, #123 ; Add 123 (decimal) to the value of R1 and place the result in R1.
• Square brackets — the operand is an indirect address. If the operand is enclosed in square brackets, the assembler treats the operand as an indirect address; that is, it uses the contents of the operand as an address. Indirect addresses consist of a base and an offset. The base is specified by a register and is formed by taking the value in the register. The offset can be specified by a register, an immediate value, or a shifted register. Furthermore, the offset can be designated as one of the following:
  • Pre-index, where the base and offset are combined to form the address. To designate a pre-index offset, include the offset within the enclosing right bracket.
  • Postindex, where the address is formed from the base, and then the base and offset are combined. To designate a postindex offset, include the offset outside of the right bracket.

The offset can be added to or subtracted from the base. The following are examples of instructions that use indirect addresses as operands:

A: LDR R1, [R1] ; Load from address in R1 into R1. LDR R7, [R1, #5] ; Form address by adding the value in R1 to 5. Load from address into R7. STR R3, [R1, -R2] ; Form address by subtracting the value in R2 from the value in R1. Store from R3 ; to memory at address. STR R14, [R1, +R3, LSL #2] ; Form address by adding the value in R3 shifted left by 2 to the value in R1. ; Store from R14 to memory at address. LDR R1, [R1], #5 ; Load from address in R1 into R1, then add 5 to the address. STR R2, [R1], R5 ; Store value in R2 in the address in R1, then add the value in R5 to the address.
• ! suffix — write-back to register. If you use the ! sign as a suffix, the assembler writes the computed address back to the base register. Write-back to register is used only with the indirect addressing mode syntax.

This is an example of an instruction using the write back to register suffix:

LDR R1, [R4, #4]! ; Form address by adding the value in R4 to 4. Load from this address into R1, ; then replace the value in R4 with the address.
• ^ suffix — set S bit. If you use the ^ sign as a suffix, the assembler sets the S bit. The resulting action depends on the type of instruction being executed and whether R15 is in the transfer list. For more information, see the LDM and STM instructions in the TMS470R1x User's Guide.
LDMIA SP, {R4-R11, R15}^ ; Load registers R4 through R11 and R15 from memory at SP. Load CPSR with SPSR.
• Shifted registers. If a register symbol is followed by a shift type, the computed value is the value in the register shifted according to the type as defined below:

LSL LSR ASL ASR ROR RRX

Logical shift left Logical shift right Arithmetic shift left Arithmetic shift right Rotate right Rotate right extended

The shift type can be followed by a register or an immediate whose value defines the shift amount. The following are examples of instructions that use shifted registers as operands:

B: ADD R1, R4, R5, LSR R2 ; Logical shift right the value in R5 by the value in R2. Add the value in R5 to R4. ; Place result in R1. LDR R1, [R5, R4, LSL #4] ; Form address by adding the value in R4 shifted left by 4 to the value in R5. ; Load from address into R1. CMP R3, R4, RRX ; Compare the value in R3 with the value in R4 rotate right extend.
• Curly braces - the operand is a register list. If you surround registers with curly braces, the assembler treats the operand as a list of registers. You can separate registers with commas or indicate a range of registers with a dash. The following are examples of instructions that use register lists:
LDMEA R2, {R1, R3, R6} ; Pre-decrement stack load. Load registers R1, R3 and R6 from memory at the address in R2. STMFD R12, {R1, R3-R5} ; Pre-increment stack store. Store from registers R1 and R3 through R5 to memory at the ; address in R12.