<学习笔记> adr 与 ldr 的使用及两者的区别（基于ARM架构 ）

<学习笔记> adr 与 ldr 的使用及两者的区别（基于ARM架构）

使用环境：
环境系统： Ubuntu 14.04.4
适用于 mini2440的工具集合：
arm-linux-cpp ： arm-none-linux-gnueabi-cpp (ctng-1.6.1) 4.4.3
arm-linux-as ： GNU assembler (GNU Binutils) 2.20
arm-linux-ld ： GNU ld (GNU Binutils) 2.20
arm-linux-objdump ：GNU objdump (GNU Binutils) 2.20

---

示例用代码

➜ ~/test: cat ldr_adr.S

.text
.globl _start

_start:
ldr r0,_reset
adr r0,_reset
ldr r0,=_reset
nop

_reset:
    mov r1,#10
nop

---

源码反汇编

➜ ~/test: arm-linux-as ldr_adr.S -o ldr_adr.o
➜ ~/test: arm-linux-objdump -d ldr_adr.o

ldr_adr.o:     file format elf32-littlearm


Disassembly of section .text:

00000000 <_start>:
   0:   e59f0008    ldr r0, [pc, #8]    ; 10 <_reset>
   4:   e28f0004    add r0, pc, #4
   8:   e59f0008    ldr r0, [pc, #8]    ; 18 <_reset+0x8>
   c:   e1a00000    nop         ; (mov r0, r0)

00000010 <_reset>:
  10:   e3a0100a    mov r1, #10
  14:   e1a00000    nop         ; (mov r0, r0)
  18:   00000010    .word   0x00000010

---

反汇编分析

1. 第一条指令： ldr r0,_reset

这是一条正常的ARM指令，目的是从内存地址中读取数值，而这里的地址值为标号”_reset”所对应的值，即0x00000010。

从反汇编结果可以看到，指令被“翻译”成了ldr r0, [pc, #8]，是根据pc值作偏移进行间接寻址访问

ARM架构规定pc值为当前执行指令地址加8,即当前指令下两条指令地址

所以：
当前地址值为：0x0
PC值为： 0x0 + 8 = 0x8
而操作数 [pc, #8] 的结果是 [0x10] (pc的值加8)，最后获取的是标号“_start”所指地址0x10存储的数据值，所以此时r0的值为e1a00000 .

2. 第三条指令(不要问我为什么是3)： ldr r0,=_reset

这是一条伪指令，会被汇编器汇编为一个ARM指令。
可以看到此时的反汇编结果与第一条指令的反汇编结果很相似: ldr r0, [pc, #8]

但是，通过细心的计算pc偏移值：
当前地址值：0x8
pc值：0x8 + 8 = 0x10
而此时的反汇编寄存器访问指令的操作数为 [pc,#8] ,结果是[0x18](pc的值再加8) ，而最后结果就是获取地址为0x18所存放的数据。

再看看反汇编代码部分：

00000010 <_reset>:
10: e3a0100a mov r1, #10
14: e1a00000 nop ; (mov r0, r0)
18: 00000010 .word 0x00000010

地址0x18所存放的值是0x00000010，这个地址值正正就是标号 _start 所对应的值，
所以最后r0获得的是标号”_start”的所对应的地址值(0x00000010)。

3. 第二条指令：adr r0,_reset

这同样也是一条伪指令，此时反汇编的结果是 : add r0, pc, #4

其通过对pc进行加减操作进而获得了某个地址值，可以仔细算算：
当前地址值：0x4
pc值为：0x4 + 8 = 0x0C

而执行反汇编的指令add r0, pc, #4后，r0的值为pc+4，即0x10
这个0x10是什么呢?
在回去看看反汇编信息,获得的值，又是标号 _start 所在的地址，所以最后r0获得的是标号”_start”的对应的值(0x00000010)。

00000010 <_reset>:
10: e3a0100a mov r1, #10
14: e1a00000 nop ; (mov r0, r0)
18: 00000010 .word 0x00000010

所以，adr伪指令会被汇编器器产生单个 ADD 或 SUB 指令来装载地址值。如果不能在一个指令中构造该地址，则生成一个错误，并且汇编失败。

---

伪指令ldr与adr

从功能上来讲，adr与ldr伪指令功能是相同的，都是获取标号所对应的地址值。
但是，他们本质上有非常大的区别，下面我们在链接阶段指定链接地址：

➜ ~/test: arm-linux-ld ldr_adr.o -Ttext 0x2000 -o ldr_adr
➜ ~/test: arm-linux-objdump -d ldr_adr

ldr_adr:     file format elf32-littlearm


Disassembly of section .text:

00002000 <_start>:
    2000:   e59f0008    ldr r0, [pc, #8]    ; 2010 <_reset>
    2004:   e28f0004    add r0, pc, #4
    2008:   e59f0008    ldr r0, [pc, #8]    ; 2018 <_reset+0x8>
    200c:   e1a00000    nop         ; (mov r0, r0)

00002010 <_reset>:
    2010:   e3a0100a    mov r1, #10
    2014:   e1a00000    nop         ; (mov r0, r0)
    2018:   00002010    .word   0x00002010
➜  ~/test: 

结果没有区别?

• 第二条指令：adr r0,_reset汇编成了add r0, pc, #4
  把”_reset”的地址加载到r0中，它是个相对地址。是相对PC作偏移获取到的地址值，是与位置无关的，他的值是不确定的，主要依赖于当前程序运行所在实际的地址空间。
  即当前PC值为0xc时，那么adr获得的地址为pc+4，那么获得的地址值r0就是0x10；而当pc值为0x200c时，那么获得的值为0x2010。

• 第三条指令ldr r0, =_start汇编成了ldr r0, [pc, #8]

  看上去这只是一个指令，但是它要占用 2 个 32bit 的空间：

  • 一个是存放指令
  • 另一个是 “_start”标号的地址值
    （因为在编译的时候不能确定 _start 的值，所以不能直接用 mov 指令来给 r0 赋一个 32bit 的常量，所以需要多出一个空间存放 _start 的真正数据值，这个数据值是在链接的时候确定）。

  伪指令 ldr 是通过创建一个内存空间的形式，取得标号 _start 的绝对地址。
  为什么说是绝对地址，因为这个地址是在链接的阶段就已经是确定的。

  • 当没有指定链接地址时：
    r0的值为从 地址0x18 获取的数据 0x00000010
  • 当指定链接地址时：
    r0的值为从 地址0x2018 获取的数据 0x00002010

  如下面的指定链接地址后，pc是通过获取地址为 地址0x2018所在内存的值，而这个值在链接阶段就已经确定，不管程序运行在哪个内存空间，他的值都是是固定不变的，获取的值都应该是0x00002010 .

00002010 <_reset>:  
    2010:   e3a0100a    mov r1, #10
    2014:   e1a00000    nop         ; (mov r0, r0)
    2018:   00002010    .word   0x00002010

---

没看出来个究竟? adr与ldr两个指令有什么用？来看看u-boot源码中的代码搬运操作：

    .globl  relocate_code
relocate_code:
    mov r4, r0  /* save addr_sp */
    mov r5, r1  /* save addr of gd */
    mov r6, r2  /* save addr of destination */

    /* Set up the stack                         */
stack_setup:
    mov sp, r4

    adr r0, _start
    cmp r0, r6
    moveq   r9, #0      /* no relocation. relocation offset(r9) = 0 */
    beq clear_bss       /* skip relocation */
    mov r1, r6          /* r1 <- scratch for copy_loop */
    ldr r3, _bss_start_ofs
    add r2, r0, r3      /* r2 <- source end address     */

copy_loop:
    ldmia   r0!, {r9-r10}       /* copy from source address [r0]    */
    stmia   r1!, {r9-r10}       /* copy to   target address [r1]    */
    cmp r0, r2                  /* until source end address [r2]    */
    blo copy_loop

先关注 adr r0, _start这条指令，他主要获取标号_start地址值，注意，这里时相对与PC值的地址 。
然后执行cmp r0, r6，这是干嘛呢？

• 其中r0代表了此时程序执行时的实际物理地址值(_start对应的是uboot源码的第一条指令的地址)，所以，此时r0是u-boot源码第一条指令所在位置，可以是任何地址值。
• r6代表了u-boot源码需要重定位的地址值，就是SDRAM的地址。

在正常情况下，SOC启动后会执行u-boot，然而一般的存储介质都不具备执行程序的条件，所以需要把u-boot代码搬运到SDRAM当中。而正常情况下这样的cmp r0, r6 得到的结果肯定是不相等的，后面就执行代码搬运操作。

而当u-boot代码本来就运行在内存当中呢？这个时候adr r0, _start 取得的地址就是SDRAM中的地址值，cmp r0, r6 得到的结果就是相等的，后面就不做搬运代码的操作，因为本来就在SDRAM中执行的u-boot。

所以adr伪指令一般都用于判断当前程序运行地址所在空间。