ARM架构使用哪个寄存器来记住返回到哪里

请问ARM架构使用哪个寄存器来记住返回到哪里
执行一个方法?
又如何使用此寄存器来控制
程序 可以的话可以提供一个例子吗

ARM架构用lr寄存器保存函数返回地址，下面是一个简单的例子

int add(int a, int b)
{
  return a+b;
}

int main()
{
  int a = 1;
  int b = 2;
  int c = add(a, b);
  return 0;
}

$ gcc -S a.c

        .arch armv6
        .eabi_attribute 28, 1
        .eabi_attribute 20, 1
        .eabi_attribute 21, 1
        .eabi_attribute 23, 3
        .eabi_attribute 24, 1
        .eabi_attribute 25, 1
        .eabi_attribute 26, 2
        .eabi_attribute 30, 6
        .eabi_attribute 34, 1
        .eabi_attribute 18, 4
        .file   "a.c"
        .text
        .align  2
        .global add
        .arch armv6
        .syntax unified
        .arm
        .fpu vfp
        .type   add, %function
add:
        @ args = 0, pretend = 0, frame = 8
        @ frame_needed = 1, uses_anonymous_args = 0
        @ link register save eliminated.
        str     fp, [sp, #-4]!   ; 保存上一层函数的帧指针到栈上
        add     fp, sp, #0       ; 设置当前帧指针
        sub     sp, sp, #12      ; 分配局部变量内存，sp-4: 上一层函数帧指针，sp-8: 局部变量a，sp-12: 局部变量b
        str     r0, [fp, #-8]    ; 把传入的第一个参数(寄存器r0)拷贝到局部变量a
        str     r1, [fp, #-12]   ; 把传入的第二个参数(寄存器r1)拷贝到局部变量b
        ldr     r2, [fp, #-8]    ; 把变量a的值读入到寄存器r2
        ldr     r3, [fp, #-12]   ; 把变量b的值读入到寄存器r3
        add     r3, r2, r3       ; 计算r2+r3，结果保存到r3
        mov     r0, r3           ; 拷贝r3到r0，寄存器r0里的值就是函数的返回值
        add     sp, fp, #0       ; 恢复栈指针
        @ sp needed
        ldr     fp, [sp], #4     ; 恢复帧指针
        bx      lr               ; 函数返回，寄存器lr是返回地址
        .size   add, .-add
        .align  2
        .global main
        .syntax unified
        .arm
        .fpu vfp
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        push    {fp, lr}          ; 把帧指针和函数返回地址压栈
        add     fp, sp, #4        ; 设置帧指针
        sub     sp, sp, #16       ; 在栈上分配局部变量内存
        mov     r3, #1            ;
        str     r3, [fp, #-8]     ; a = 1
        mov     r3, #2
        str     r3, [fp, #-12]    ; b = 2
        ldr     r1, [fp, #-12]    ; 把b的值拷贝到r1，r1是传给子函数的第二个参数
        ldr     r0, [fp, #-8]     ; 把a的值拷贝到r0，r0是传给子函数的第一个参数
        bl      add               ; 调用子函数add，函数返回地址保存到lr寄存器
        str     r0, [fp, #-16]    ; 寄存器r0里的值是函数返回值，把函数返回值拷贝到局部变量c中
        mov     r3, #0
        mov     r0, r3            ; main函数返回值0
        sub     sp, fp, #4        ; 恢复栈指针
        @ sp needed
        pop     {fp, pc}          ; main函数返回
        .size   main, .-main
        .ident  "GCC: (Raspbian 8.3.0-6+rpi1) 8.3.0"
        .section        .note.GNU-stack,"",%progbits

看是32位处理器还是64位了。32位就是lr，64位是r30。