Loading 32 bit values to a register in arm assembly

Question

I want to load 1 32 bit hexadecimal directly into a register using arm assembly.

mov r1,#0x6c617669

This cannot be used because from this instruction we can only load 8 bit values. So I have load the 32 bit value directly from the memory. So how can I store the 32 bit value in memory and load it directly to a register using arm assembly?

I tried this code.

    .global main
main:
    sub sp,sp,#4
    str lr,[sp,#0]

    sub sp,sp,#4
    str r0,x
    add sp,sp,#4

    ldr lr,[sp,#0]
    add sp,sp,#4
    mov pc,lr

    .data
x: .word 0x6c617669

But gives the following error.

test1.s: Assembler messages: 
test1.s:45: Error: internal_relocation (type: OFFSET_IMM) not fixed up

Answer 1

You have two basic choices. You can load it or build up the register 8 non-zero bits at a time

mov r0,#0x12000000             @ construct from 8-bit rotated immediates
orr r0,r0,#0x00340000
orr r0,r0,#0x00005600
orr r0,r0,#0x00000078
...

ldr r1,=0x12345678             @ let the assembler figure out how
...

ldr r3,myconst                 @ explicitly load from a nearby constant
...
myconst: .word 0x12345678

The latter two are the same, the equals trick simply asks the assembler to place the value within reach and do a pc relative load.

Answer 2

Depending on your processor you may be able to use another set of instructions (i.e., movw & movt). For example, the instructions below will not work on Raspberry Pi 2 using GCC; however, they will work on the Marvell Armada 370/XP; which, if I recall correctly, is a Cortex-A9

movw r1, #0x6c61
movt r1, #0x7669

...

r1 0x6c617669 1818326633

Answer 3

You can do it in another way, indirectly instead of directly:

.data

.balign 4
value: .word 0x6c617669

.text

.global main
main:
    push {lr}                        /* save lr value on stack */

    ldr r0, address_of_value         /* r0 = &value */
    ldr r0, [r0]                     /* r0 = *r0 = value */

    pop {lr}                         /* load lr (R14) register from stack */
    bx lr                            /* return from main using lr */

address_of_value: .word value

The R0 register contains the 32bit value as you can see debugging this code:

(gdb) start
Temporary breakpoint 1 at 0x103ec
Starting program: /home/pi/asm/kk

Temporary breakpoint 1, 0x000103ec in main ()
(gdb) disassemble
Dump of assembler code for function main:
   0x000103e8 <+0>:     push    {lr}            ; (str lr, [sp, #-4]!)
=> 0x000103ec <+4>:     ldr     r0, [pc, #8]    ; 0x103fc <address_of_value>
   0x000103f0 <+8>:     ldr     r0, [r0]
   0x000103f4 <+12>:    pop     {lr}            ; (ldr lr, [sp], #4)
   0x000103f8 <+16>:    bx      lr
End of assembler dump.
(gdb) info registers r0
r0             0x1      1
(gdb) stepi
0x000103f0 in main ()
(gdb) stepi
0x000103f4 in main ()
(gdb) disassemble
Dump of assembler code for function main:
   0x000103e8 <+0>:     push    {lr}            ; (str lr, [sp, #-4]!)
   0x000103ec <+4>:     ldr     r0, [pc, #8]    ; 0x103fc <address_of_value>
   0x000103f0 <+8>:     ldr     r0, [r0]
=> 0x000103f4 <+12>:    pop     {lr}            ; (ldr lr, [sp], #4)
   0x000103f8 <+16>:    bx      lr
End of assembler dump.
(gdb) info registers r0
r0             0x6c617669       1818326633

Regards.