Why use LDR over MOV (or vice versa) in ARM assembly?

by

It is a trick/shortcut. say for example

ldr r0,=main

what would happen is the assembler would allocate a data word, near the instruction but outside the instruction path

ldr r0,main_addr
...
b somewhere
main_addr: .data main

Now expand that trick to constants/immediates, esp those that cannot fit into a move immediate instruction:

top:
add r1,r2,r3
ldr r0,=0x12345678
eor r1,r2,r3
eor r1,r2,r3
b top

assemble then disassemble

00000000 <top>:
   0:   e0821003    add r1, r2, r3
   4:   e59f0008    ldr r0, [pc, #8]    ; 14 <top+0x14>
   8:   e0221003    eor r1, r2, r3
   c:   e0221003    eor r1, r2, r3
  10:   eafffffa    b   0 <top>
  14:   12345678    eorsne  r5, r4, #125829120  ; 0x7800000

and you see the assembler has added the data word for you and changed the ldr into a pc relative for you.

now if you use an immediate that does fit in a mov instruction, then depending on the assembler perhaps, certainly with the gnu as I am using, it turned it into a mov for me

top:
add r1,r2,r3
ldr r0,=0x12345678
ldr r5,=1
mov r6,#1
eor r1,r2,r3
eor r1,r2,r3
b top


00000000 <top>:
   0:   e0821003    add r1, r2, r3
   4:   e59f0010    ldr r0, [pc, #16]   ; 1c <top+0x1c>
   8:   e3a05001    mov r5, #1
   c:   e3a06001    mov r6, #1
  10:   e0221003    eor r1, r2, r3
  14:   e0221003    eor r1, r2, r3
  18:   eafffff8    b   0 <top>
  1c:   12345678    eorsne  r5, r4, #125829120  ; 0x7800000

So it is basically a typing shortcut, understand that you are giving the assembler the power to find a place to stick the constant, which it usually does a good job, sometimes complains, not sure if I have seen it fail to do it safely. Sometimes you need a .ltorg or .pool in the code to encourage the assembler to find a place.

More Related Contents:

  1. Difference between movq and movabsq in x86-64
  2. Why does the ARM PC register point to the instruction after the next one to be executed?
  3. why we can’t move a 64-bit immediate value to memory?
  4. Set all bits in CPU register to 1 efficiently
  5. What is the difference between =label (equals sign) and [label] (brackets) in ARMv6 assembly?
  6. How to run a single line of assembly, then see [R1] and condition flags
  7. Can I add 64bit constants to 64bit registers?
  8. Getting an label address to a register on ARM?
  9. What are the semantics of ADRP and ADRL instructions in ARM assembly?
  10. What’s difference between number with $ or without $ symbol in at&t assembly syntax?
  11. Converting Int to Float or Float to Int using Bitwise operations (software floating point)
  12. Referencing the contents of a memory location. (x86 addressing modes)
  13. What considerations go into predicting latency for operations on modern superscalar processors and how can I calculate them by hand?
  14. Why does the x86-64 / AMD64 System V ABI mandate a 16 byte stack alignment?
  15. Why in x86-64 the virtual address are 4 bits shorter than physical (48 bits vs. 52 long)?
  16. Is a sign or zero extension required when adding a 32bit offset to a pointer for the x86-64 ABI?
  17. Printing floating point numbers from x86-64 seems to require %rbp to be saved
  18. Assembly 8086 | Sum of an array, printing multi-digit numbers
  19. How do you use gcc to generate assembly code in Intel syntax?
  20. What is stack frame in assembly?
  21. Distinguishing memory from constant in GNU as .intel_syntax
  22. How to push a 64bit int in NASM?
  23. x64 instruction encoding and the ModRM byte
  24. Is this code correct (Number plus number, then print the result)
  25. Why does the PLT exist in addition to the GOT, instead of just using the GOT?
  26. How to read and write x86 flags registers directly?
  27. Add 2 numbers and print the result using Assembly x86
  28. How to transpose a 16×16 matrix using SIMD instructions?
  29. Adding two 64 bit numbers in Assembly
  30. Why do we even need assembler when we have compiler?

Leave a Comment