ARM 汇编中的 loRecursion 示例
loRecursion Example in ARM Assembly
谁能给我一个例子，说明如何仅使用此处列出的指令（用于 visUAL）在 ARM 汇编中完成递归？
我正在尝试为 class 执行递归斐波那契和阶乘函数。我知道递归是一个调用函数的函数，但我不知道如何在ARM中模拟它。
https://salmanarif.bitbucket.io/visual/supported_instructions.html
万一 link 不起作用，我正在使用 visUAL，这些是我可以使用的唯一说明：
- MOV
- MVN
- ADR
- LDR
- 添加
- ADC
- 订阅
- 单板机
- RSB
- RSC
- 和
- 复议
- BIC
- ORR
- LSL
- LSR
- ASR
- ROR
- RRX
- CMP
- CMN
- 尖沙咀
- TEQ
- LDR
- LDM
- STM
- B
- BL
- 填充
- 结束
这不会为 R4 加载旧值，因此每次函数调用自身时 R4 都会加倍。
;VisUAL initializess all registers to 0 except for R13/SP, which is -16777216
MOV R4, #0
MOV R5, #1
MOV r0, #4
MOV LR, #16 ;tells program to move to 4th instruction
FIB
STMDB SP!, {R4-R6, LR} ;Stores necessary values on stack (PUSH command)
LDR R4, [SP] ;Loads older value for R4 from memory
ADD R4, R4, R5 ;Adds R5 to R4
STR R4, [SP], #8 ;stores current value for R4 to memory
MOV R5, R4 ;Makes R5 = R4
CMP R4, #144 ;If R4 >= 144:
BGE POP ;Branch to POP
MOV PC, LR ;Moves to STMDB(PUSH) statement
POP
LDMIA SP!, {R4-R6, LR} ;Pops registers off stack
END ;ends program
您需要使用堆栈、STMDB和LDMIA指令。在具有 "unified" 表示法的真实 ARM 工具上，它们还具有助记符 PUSH 和 POP。
Fibonnaci 和阶乘不是很好的例子，因为它们不 "need" 递归。但是让我们假装他们这样做。我会选择 Fibonacci，因为你没有 MUL 指令！？你想做这样的事情：
START
MOV R0, #6
BL FIB
END ; pseudo-instruction to make your simulator terminate
FIB ; int fib(int i) {
STMDB SP!, {R4,R5,R6,LR} ; int n, tmp;
MOV R4, R0 ; n = i;
CMP R0, #2 ; if (i <= 2) {
MOV R0, #1 ; return 1;
BLE FIB_END ; }
SUB R0, R4, #2 ; i = n-2;
BL FIB ; i = fib(i);
MOV R5, R0 ; tmp = i;
SUB R0, R4, #1 ; i = n-1;
BL FIB ; i = fib(i);
ADD R0, R0, R5 ; i = i + tmp;
FIB_END ; return i;
LDMIA SP!, {R4,R5,R6,PC} ; }
它应该以包含 fib(6) == 8 的 R0 终止。当然，这段代码非常低效，因为它会针对相同的值重复调用 FIB。
需要 STM，以便您可以使用寄存器 r4、r5，因为另一个函数调用可以更改 r0-r3 和 LR。推 LR 和弹出 PC 就像 B LR。如果您正在调用 C 代码，您应该压入偶数个寄存器以保持 SP 64 位对齐（我们实际上不需要在这里这样做；忽略 R6）。
其他一些递归函数：
unsigned int so ( unsigned int x )
{
static unsigned int z=0;
z+=x;
if(x==0) return(z);
so(x-1);
return(z);
}
build/disassemble
arm-none-eabi-gcc -O2 -c Desktop/so.c -o so.o
arm-none-eabi-objdump -D so.o
00000000 <so>:
0: e92d4010 push {r4, lr}
4: e59f4034 ldr r4, [pc, #52] ; 40 <so+0x40>
8: e5943000 ldr r3, [r4]
c: e3500000 cmp r0, #0
10: e0803003 add r3, r0, r3
14: e5843000 str r3, [r4]
18: 1a000002 bne 28 <so+0x28>
1c: e1a00003 mov r0, r3
20: e8bd4010 pop {r4, lr}
24: e12fff1e bx lr
28: e2400001 sub r0, r0, #1
2c: ebfffffe bl 0 <so>
30: e5943000 ldr r3, [r4]
34: e8bd4010 pop {r4, lr}
38: e1a00003 mov r0, r3
3c: e12fff1e bx lr
40: 00000000
如果你不明白它是否值得。让工具帮你做是作弊吗？
push 是 stm 的伪指令，pop 是 ldm 的伪指令，所以你可以使用它们。
我使用了一个静态局部变量，我称之为局部全局变量，它位于 .data 中而不是堆栈中（在这种情况下是 .bss，因为我将其设置为零）
Disassembly of section .bss:
00000000 <z.4099>:
0: 00000000
首先要加载的是将此值加载到 r3。
调用约定说 r0 将包含进入函数的第一个参数（也有例外，但在这种情况下是正确的）。
所以我们去从内存中获取z，r0已经有参数x所以我们将x添加到z并保存到内存
编译器出于性能原因进行了乱序比较，所写的 add 和 str 不修改标志，所以没关系，
如果 x 不等于零，它分支到 28，它执行 so(x-1) 调用
从内存中读回 r3（调用约定说 r0-r3 是易变的函数，您可以随意修改它们并且不必保留它们，因此我们在 r3 中的 z 版本可能已被破坏但 r4 被任何被调用者保留，所以我们将 z 读回 r3。我们从堆栈弹出 r4 和 return 地址，我们用 z 准备 return 寄存器 r0 并执行 return.
如果 x 等于零（bne on 18 failed we 运行 1c, then 20, then 24) then we copy z (r3 version) into r0 which is the register used for return 根据此编译器使用的调用约定从此函数中调用（武器推荐）。和 returns.
链接器将把 z 的地址填充到偏移量 0x40，这是一个对象而不是最终二进制文件...
arm-none-eabi-ld -Ttext=0x1000 -Tbss=0x2000 so.o -o so.elf
arm-none-eabi-ld: warning: cannot find entry symbol _start; defaulting to 0000000000001000
arm-none-eabi-objdump -D so.elf
so.elf: file format elf32-littlearm
Disassembly of section .text:
00001000 <so>:
1000: e92d4010 push {r4, lr}
1004: e59f4034 ldr r4, [pc, #52] ; 1040 <so+0x40>
1008: e5943000 ldr r3, [r4]
100c: e3500000 cmp r0, #0
1010: e0803003 add r3, r0, r3
1014: e5843000 str r3, [r4]
1018: 1a000002 bne 1028 <so+0x28>
101c: e1a00003 mov r0, r3
1020: e8bd4010 pop {r4, lr}
1024: e12fff1e bx lr
1028: e2400001 sub r0, r0, #1
102c: ebfffff3 bl 1000 <so>
1030: e5943000 ldr r3, [r4]
1034: e8bd4010 pop {r4, lr}
1038: e1a00003 mov r0, r3
103c: e12fff1e bx lr
1040: 00002000
Disassembly of section .bss:
00002000 <z.4099>:
2000: 00000000
这里的重点不是欺骗和使用编译器，这里的重点是递归函数没有什么神奇的，如果你遵循调用约定或任何你喜欢的术语，当然不是。
例如
如果你有参数 r0 是第一个，r1 第二个，直到 r3（如果它们适合，使你的代码适合并且你有四个或更少的参数）
return 值在 r0 中，如果它适合
您需要将 lr 压入堆栈，因为您将调用另一个函数
r4 on up preserve 如果你需要修改它们，如果你想要一些本地存储要么通过相应地修改堆栈指针（或做pushes/stms）来使用堆栈。你可以看到 gcc 将寄存器中的内容保存到堆栈中，然后在函数期间使用寄存器，至少有几个局部变量值，除此之外它需要在堆栈上进行大量操作，sp 相对。
当您执行递归调用时，您会按照调用约定像执行任何其他正常函数一样执行此操作，如果您需要在调用前保存 r0-r3，则在寄存器 r4 或以上或堆栈中执行此操作，在调用之后恢复函数 returns。您可以看到，将函数调用前后要保留的值放在寄存器 r4 或更高版本中会更容易。
编译器可以在分支之前完成 r0 的比较，这样读起来更容易。同样可以在 pop
之前将 return 值的 mov 移动到 r0
我没有放参数，所以我这里的 gcc 构建似乎是 armv4t，如果我要求更新一点的话
arm-none-eabi-gcc -O2 -c -mcpu=mpcore Desktop/so.c -o so.o
arm-none-eabi-objdump -D so.o
so.o: file format elf32-littlearm
Disassembly of section .text:
00000000 <so>:
0: e92d4010 push {r4, lr}
4: e59f402c ldr r4, [pc, #44] ; 38 <so+0x38>
8: e3500000 cmp r0, #0
c: e5943000 ldr r3, [r4]
10: e0803003 add r3, r0, r3
14: e5843000 str r3, [r4]
18: 1a000001 bne 24 <so+0x24>
1c: e1a00003 mov r0, r3
20: e8bd8010 pop {r4, pc}
24: e2400001 sub r0, r0, #1
28: ebfffffe bl 0 <so>
2c: e5943000 ldr r3, [r4]
30: e1a00003 mov r0, r3
34: e8bd8010 pop {r4, pc}
38: 00000000
您可以看到 return 读起来更容易一些
虽然错过了优化，但它本可以执行 ldr r0,[r4] 并保存一条指令。或者保持尾端不变，bne 可能是 beq 到 30 (mov r0,r3; pop{r4,pc} 并共享一个出口。
更具可读性
so:
push {r4, lr}
@ z += x
ldr r4, zptr
ldr r3, [r4]
add r3, r0, r3
str r3, [r4]
@ if x==0 return z
cmp r0, #0
beq l30
@ so(x - 1)
sub r0, r0, #1
bl so
ldr r3, [r4]
l30:
@ return z
mov r0, r3
pop {r4, pc}
zptr: .word z
.section .bss
z: .word 0
arm-none-eabi-as so.s -o so.o
arm-none-eabi-objdump -D so.o
so.o: file format elf32-littlearm
Disassembly of section .text:
00000000 <so>:
0: e92d4010 push {r4, lr} (stmdb)
4: e59f4024 ldr r4, [pc, #36] ; 30 <zptr>
8: e5943000 ldr r3, [r4]
c: e0803003 add r3, r0, r3
10: e5843000 str r3, [r4]
14: e3500000 cmp r0, #0
18: 0a000002 beq 28 <l30>
1c: e2400001 sub r0, r0, #1
20: ebfffff6 bl 0 <so>
24: e5943000 ldr r3, [r4]
00000028 <l30>:
28: e1a00003 mov r0, r3
2c: e8bd8010 pop {r4, pc} (ldmia)
00000030 <zptr>:
30: 00000000
Disassembly of section .bss:
00000000 <z>:
0: 00000000
编辑
让我们来看看最后一个。
push {r4,lr} which is a pseudo instruction for stmdb sp!,{r4,lr}
Lr is the r14 which is the return address look at the bl instruction
branch and link, so we branch to some address but lr (link register) is
set to the return address, the instruction after the bl. So when main or some other function calls so(4); lets assume so is at address 0x1000 so the program counter, r15, pc gets 0x1000, lr will get the value of the instruction after the caller so lets say that is 0x708. Lets also assume the stack pointer during this first call to so() from main is at 0x8000, and lets say that .bss is at 0x2000 so z lives at address 0x2000 (which also means the value at 0x1030, zptr is 0x2000.
We enter the function for the first time with r0 (x) = 4.
When you read the arm docs for stmdb sp!,{r4,lr} it decrements before (db) so sp on entry this time is 0x8000 so it decrements for the two items to 0x7FF8, the first item in the list is written there so
0x7FF8 = r4 from main
0x7FFC = 9x 0x708 return address to main
the ! means sp stays modified so sp-0x7ff8
then ldr r4,zptr r4 = 0x2000
ldr r3,[r4] this is an indirect load so what is at address r4 is read to
put in r3 so r3 = [0x2000] = 0x0000 at this point the z variable.
z+=x; add r3,r0,r3 r3 = r0 + r3 = 4 + 0 = 4
str r3,[r4] [r4] = r3, [0x2000] = r3 write 4 to 0x2000
cmp r0,#0 4 != 0
beq to 28 nope, not equal so no branch
sub r0,r0,#1 r0 = 4 - 1 = 3
bl so so this is so(3); pc = 0x1000 lr = 0x1024
so now we enter so for the second time with r0 = 3
stmdb sp!,{r4,lr}
0x7FF0 = r4 (saving from so(4) call but we dont care its value even though we know it)
0x7FF4 = lr from so(4) = 0x1024
sp=0x7FF0
ldr r4,zptr r4 = 0x2000
ldr r3,[r4] r3 = [0x2000] = 4
add r3,r0,r3 r3 = 3 + 4 = 7
str r3,[r4] write 7 to 0x2000
cmp r0,#0 3 != 0
beq 0x1028 not equal so dont branch
sub r0,r0,#1 r0 = 3-1 = 2
bl so pc=0x1000 lr=0x1024
so(2)
stmdb sp!,{r4,lr}
0x7FE8 = r4 from caller, just save it
0x7FEC = lr from caller, 0x1024
sp=0x7FE8
ldr r4,zprt r4=0x2000
ldr r3,[r4] r3 = read 7 from 0x2000
add r3,r0,r3 r3 = 2 + 7 = 9
str r3,[r4] write 9 to 0x2000
cmp r0,#0 2 != 0
beq 0x1028 not equal so dont branch
sub r0,r0,#1 r0 = 2 - 1 = 1
bl 0x1000 pc=0x1000 lr=0x1024
so(1)
stmdb sp!,{r4,lr}
0x7FE0 = save r4
0x7FE4 = lr = 0x1024
sp=0x7FE0
ldr r4,zptr r4=0x2000
ldr r3,[r4] r3 = read 9 from 0x2000
add r3,r0,r3 r3 = 1 + 9 = 10
str r3,[r4] write 10 to 0x2000
cmp r0,#0 1 != 0
beq 0x1028 not equal so dont branch
sub r0,r0,#1 r0 = 1 - 1 = 0
bl 0x1000 pc=0x1000 lr=0x1024
so(0)
stmdb sp!,{r4,lr}
0x7FD8 = r4
0x7FDC = lr = 0x1024
sp = 0x7FD8
ldr r4,zptr r4 = 0x2000
ldr r3,[r4] r3 = read 10 from 0x2000
add r3,r0,r3 r3 = 0 + 10 = 10
str r0,[r4] write 10 to 0x2000
cmp r0,#0 0 = 0 so it matches
beq 0x1028 it is equal so we finally take this branch
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
increment after
r4 = [sp+0] = [0x7FD8] restore r4 from caller
pc = [sp+4] = [0x7FDC] = 0x1024
sp += 8 = 0x7FE0
(branch to 0x1024)(return from so(0) to so(1))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FE0] restore r4 from caller
pc = [sp+4] = [0x7FE4] = 0x1024
sp += 8 = 0x7FE8
(branch to 0x1024)(return from so(1) to so(2))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FE8] restore r4 from caller
pc = [sp+4] = [0x7FEC] = 0x1024
sp += 8 = 0x7FF0
(branch to 0x1024)(return from so(2) to so(3))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FF0] restore r4 from caller
pc = [sp+4] = [0x7FF4] = 0x1024
sp += 8 = 0x7FF8
(branch to 0x1024)(return from so(3) to so(4))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FF8] restore r4 from caller (main()'s r4)
pc = [sp+4] = [0x7FFC] = 0x708
sp += 8 = 0x8000
(branch to 0x708)(return from so(4) to main())
and we are done.
一个堆栈就像一个迪克西杯架，可能在你的时代之前。一个杯架，您可以在其中拉下一个杯子，然后将下一个杯子和其余杯子留在杯架中，您可以将一个杯子推回那里。
所以堆栈是函数的临时存储，在杯子上写一个数据项，然后将其推入支架（从调用者那里保存 r4）写入另一个项目并将其推入支架（lr，return 来自来电者的地址）。我们在这里每个功能只使用了两个项目，所以每个功能我可以将两个杯子推入支架，每次调用该功能我都会得到两个新的和唯一的存储位置来存储这个本地信息。当我退出该功能时，我将两个杯子从支架上拉下来并使用它们的值（并丢弃它们）。这在某种程度上是递归的关键，堆栈为每次调用提供新的本地存储，与之前对同一函数的调用分开，如果没有别的你需要一个 return 地址（尽管确实做了一些更简单的递归优化后没有的示例足够聪明，基本上可以从中创建一个循环）。
ldr rd,[rn] 认为他 brakets 说的是那个地址的项目，所以读取 rn 中地址处的内存并将该值保存在 rd 中。
str rd,[rn] 一个乱七八糟的 arm 指令作为其余部分 第一个参数是等号的左侧 (add r1,r2,r3 r1 = r2 + r3, ldr r1,[r4] r1 = [r4]) 这个是向后的 [rn] = rd 将 rd 中的值存储到地址 r4 所描述的内存位置，一级间接。
stmdb sp!, 意思是在做任何事情之前将堆栈指针递减 4 字节乘以列表中的寄存器数量，然后将第一个、最低编号的寄存器写入 [sp+0]，然后写入 [sp+4] ] 依此类推，最后一个会比sp的起始值小四。这 ！意味着函数结束时 sp 是该递减值。您可以将 ldm/stm 用于堆栈推送和弹出之外的其他内容。像 memcpy，但那是另外一回事了...
所有这些都在您应该已经拥有的 infocenter.arm.com 的 arm 文档中（arm 体系结构参考手册，如果您还没有阅读，armv5 是首选）。
谁能给我一个例子，说明如何仅使用此处列出的指令（用于 visUAL）在 ARM 汇编中完成递归？
我正在尝试为 class 执行递归斐波那契和阶乘函数。我知道递归是一个调用函数的函数，但我不知道如何在ARM中模拟它。
https://salmanarif.bitbucket.io/visual/supported_instructions.html
万一 link 不起作用，我正在使用 visUAL，这些是我可以使用的唯一说明：
- MOV
- MVN
- ADR
- LDR
- 添加
- ADC
- 订阅
- 单板机
- RSB
- RSC
- 和
- 复议
- BIC
- ORR
- LSL
- LSR
- ASR
- ROR
- RRX
- CMP
- CMN
- 尖沙咀
- TEQ
- LDR
- LDM
- STM
- B
- BL
- 填充
- 结束
这不会为 R4 加载旧值，因此每次函数调用自身时 R4 都会加倍。
;VisUAL initializess all registers to 0 except for R13/SP, which is -16777216
MOV R4, #0
MOV R5, #1
MOV r0, #4
MOV LR, #16 ;tells program to move to 4th instruction
FIB
STMDB SP!, {R4-R6, LR} ;Stores necessary values on stack (PUSH command)
LDR R4, [SP] ;Loads older value for R4 from memory
ADD R4, R4, R5 ;Adds R5 to R4
STR R4, [SP], #8 ;stores current value for R4 to memory
MOV R5, R4 ;Makes R5 = R4
CMP R4, #144 ;If R4 >= 144:
BGE POP ;Branch to POP
MOV PC, LR ;Moves to STMDB(PUSH) statement
POP
LDMIA SP!, {R4-R6, LR} ;Pops registers off stack
END ;ends program
您需要使用堆栈、STMDB和LDMIA指令。在具有 "unified" 表示法的真实 ARM 工具上，它们还具有助记符 PUSH 和 POP。
Fibonnaci 和阶乘不是很好的例子，因为它们不 "need" 递归。但是让我们假装他们这样做。我会选择 Fibonacci，因为你没有 MUL 指令！？你想做这样的事情：
START
MOV R0, #6
BL FIB
END ; pseudo-instruction to make your simulator terminate
FIB ; int fib(int i) {
STMDB SP!, {R4,R5,R6,LR} ; int n, tmp;
MOV R4, R0 ; n = i;
CMP R0, #2 ; if (i <= 2) {
MOV R0, #1 ; return 1;
BLE FIB_END ; }
SUB R0, R4, #2 ; i = n-2;
BL FIB ; i = fib(i);
MOV R5, R0 ; tmp = i;
SUB R0, R4, #1 ; i = n-1;
BL FIB ; i = fib(i);
ADD R0, R0, R5 ; i = i + tmp;
FIB_END ; return i;
LDMIA SP!, {R4,R5,R6,PC} ; }
它应该以包含 fib(6) == 8 的 R0 终止。当然，这段代码非常低效，因为它会针对相同的值重复调用 FIB。
需要 STM，以便您可以使用寄存器 r4、r5，因为另一个函数调用可以更改 r0-r3 和 LR。推 LR 和弹出 PC 就像 B LR。如果您正在调用 C 代码，您应该压入偶数个寄存器以保持 SP 64 位对齐（我们实际上不需要在这里这样做；忽略 R6）。
其他一些递归函数：
unsigned int so ( unsigned int x )
{
static unsigned int z=0;
z+=x;
if(x==0) return(z);
so(x-1);
return(z);
}
build/disassemble
arm-none-eabi-gcc -O2 -c Desktop/so.c -o so.o
arm-none-eabi-objdump -D so.o
00000000 <so>:
0: e92d4010 push {r4, lr}
4: e59f4034 ldr r4, [pc, #52] ; 40 <so+0x40>
8: e5943000 ldr r3, [r4]
c: e3500000 cmp r0, #0
10: e0803003 add r3, r0, r3
14: e5843000 str r3, [r4]
18: 1a000002 bne 28 <so+0x28>
1c: e1a00003 mov r0, r3
20: e8bd4010 pop {r4, lr}
24: e12fff1e bx lr
28: e2400001 sub r0, r0, #1
2c: ebfffffe bl 0 <so>
30: e5943000 ldr r3, [r4]
34: e8bd4010 pop {r4, lr}
38: e1a00003 mov r0, r3
3c: e12fff1e bx lr
40: 00000000
如果你不明白它是否值得。让工具帮你做是作弊吗？
push 是 stm 的伪指令，pop 是 ldm 的伪指令，所以你可以使用它们。
我使用了一个静态局部变量，我称之为局部全局变量，它位于 .data 中而不是堆栈中（在这种情况下是 .bss，因为我将其设置为零）
Disassembly of section .bss:
00000000 <z.4099>:
0: 00000000
首先要加载的是将此值加载到 r3。
调用约定说 r0 将包含进入函数的第一个参数（也有例外，但在这种情况下是正确的）。
所以我们去从内存中获取z，r0已经有参数x所以我们将x添加到z并保存到内存
编译器出于性能原因进行了乱序比较，所写的 add 和 str 不修改标志，所以没关系，
如果 x 不等于零，它分支到 28，它执行 so(x-1) 调用 从内存中读回 r3（调用约定说 r0-r3 是易变的函数，您可以随意修改它们并且不必保留它们，因此我们在 r3 中的 z 版本可能已被破坏但 r4 被任何被调用者保留，所以我们将 z 读回 r3。我们从堆栈弹出 r4 和 return 地址，我们用 z 准备 return 寄存器 r0 并执行 return.
如果 x 等于零（bne on 18 failed we 运行 1c, then 20, then 24) then we copy z (r3 version) into r0 which is the register used for return 根据此编译器使用的调用约定从此函数中调用（武器推荐）。和 returns.
链接器将把 z 的地址填充到偏移量 0x40，这是一个对象而不是最终二进制文件...
arm-none-eabi-ld -Ttext=0x1000 -Tbss=0x2000 so.o -o so.elf
arm-none-eabi-ld: warning: cannot find entry symbol _start; defaulting to 0000000000001000
arm-none-eabi-objdump -D so.elf
so.elf: file format elf32-littlearm
Disassembly of section .text:
00001000 <so>:
1000: e92d4010 push {r4, lr}
1004: e59f4034 ldr r4, [pc, #52] ; 1040 <so+0x40>
1008: e5943000 ldr r3, [r4]
100c: e3500000 cmp r0, #0
1010: e0803003 add r3, r0, r3
1014: e5843000 str r3, [r4]
1018: 1a000002 bne 1028 <so+0x28>
101c: e1a00003 mov r0, r3
1020: e8bd4010 pop {r4, lr}
1024: e12fff1e bx lr
1028: e2400001 sub r0, r0, #1
102c: ebfffff3 bl 1000 <so>
1030: e5943000 ldr r3, [r4]
1034: e8bd4010 pop {r4, lr}
1038: e1a00003 mov r0, r3
103c: e12fff1e bx lr
1040: 00002000
Disassembly of section .bss:
00002000 <z.4099>:
2000: 00000000
这里的重点不是欺骗和使用编译器，这里的重点是递归函数没有什么神奇的，如果你遵循调用约定或任何你喜欢的术语，当然不是。
例如
如果你有参数 r0 是第一个，r1 第二个，直到 r3（如果它们适合，使你的代码适合并且你有四个或更少的参数） return 值在 r0 中，如果它适合 您需要将 lr 压入堆栈，因为您将调用另一个函数 r4 on up preserve 如果你需要修改它们，如果你想要一些本地存储要么通过相应地修改堆栈指针（或做pushes/stms）来使用堆栈。你可以看到 gcc 将寄存器中的内容保存到堆栈中，然后在函数期间使用寄存器，至少有几个局部变量值，除此之外它需要在堆栈上进行大量操作，sp 相对。 当您执行递归调用时，您会按照调用约定像执行任何其他正常函数一样执行此操作，如果您需要在调用前保存 r0-r3，则在寄存器 r4 或以上或堆栈中执行此操作，在调用之后恢复函数 returns。您可以看到，将函数调用前后要保留的值放在寄存器 r4 或更高版本中会更容易。 编译器可以在分支之前完成 r0 的比较，这样读起来更容易。同样可以在 pop
之前将 return 值的 mov 移动到 r0我没有放参数，所以我这里的 gcc 构建似乎是 armv4t，如果我要求更新一点的话
arm-none-eabi-gcc -O2 -c -mcpu=mpcore Desktop/so.c -o so.o
arm-none-eabi-objdump -D so.o
so.o: file format elf32-littlearm
Disassembly of section .text:
00000000 <so>:
0: e92d4010 push {r4, lr}
4: e59f402c ldr r4, [pc, #44] ; 38 <so+0x38>
8: e3500000 cmp r0, #0
c: e5943000 ldr r3, [r4]
10: e0803003 add r3, r0, r3
14: e5843000 str r3, [r4]
18: 1a000001 bne 24 <so+0x24>
1c: e1a00003 mov r0, r3
20: e8bd8010 pop {r4, pc}
24: e2400001 sub r0, r0, #1
28: ebfffffe bl 0 <so>
2c: e5943000 ldr r3, [r4]
30: e1a00003 mov r0, r3
34: e8bd8010 pop {r4, pc}
38: 00000000
您可以看到 return 读起来更容易一些
虽然错过了优化，但它本可以执行 ldr r0,[r4] 并保存一条指令。或者保持尾端不变，bne 可能是 beq 到 30 (mov r0,r3; pop{r4,pc} 并共享一个出口。
更具可读性
so:
push {r4, lr}
@ z += x
ldr r4, zptr
ldr r3, [r4]
add r3, r0, r3
str r3, [r4]
@ if x==0 return z
cmp r0, #0
beq l30
@ so(x - 1)
sub r0, r0, #1
bl so
ldr r3, [r4]
l30:
@ return z
mov r0, r3
pop {r4, pc}
zptr: .word z
.section .bss
z: .word 0
arm-none-eabi-as so.s -o so.o
arm-none-eabi-objdump -D so.o
so.o: file format elf32-littlearm
Disassembly of section .text:
00000000 <so>:
0: e92d4010 push {r4, lr} (stmdb)
4: e59f4024 ldr r4, [pc, #36] ; 30 <zptr>
8: e5943000 ldr r3, [r4]
c: e0803003 add r3, r0, r3
10: e5843000 str r3, [r4]
14: e3500000 cmp r0, #0
18: 0a000002 beq 28 <l30>
1c: e2400001 sub r0, r0, #1
20: ebfffff6 bl 0 <so>
24: e5943000 ldr r3, [r4]
00000028 <l30>:
28: e1a00003 mov r0, r3
2c: e8bd8010 pop {r4, pc} (ldmia)
00000030 <zptr>:
30: 00000000
Disassembly of section .bss:
00000000 <z>:
0: 00000000
编辑
让我们来看看最后一个。
push {r4,lr} which is a pseudo instruction for stmdb sp!,{r4,lr}
Lr is the r14 which is the return address look at the bl instruction
branch and link, so we branch to some address but lr (link register) is
set to the return address, the instruction after the bl. So when main or some other function calls so(4); lets assume so is at address 0x1000 so the program counter, r15, pc gets 0x1000, lr will get the value of the instruction after the caller so lets say that is 0x708. Lets also assume the stack pointer during this first call to so() from main is at 0x8000, and lets say that .bss is at 0x2000 so z lives at address 0x2000 (which also means the value at 0x1030, zptr is 0x2000.
We enter the function for the first time with r0 (x) = 4.
When you read the arm docs for stmdb sp!,{r4,lr} it decrements before (db) so sp on entry this time is 0x8000 so it decrements for the two items to 0x7FF8, the first item in the list is written there so
0x7FF8 = r4 from main
0x7FFC = 9x 0x708 return address to main
the ! means sp stays modified so sp-0x7ff8
then ldr r4,zptr r4 = 0x2000
ldr r3,[r4] this is an indirect load so what is at address r4 is read to
put in r3 so r3 = [0x2000] = 0x0000 at this point the z variable.
z+=x; add r3,r0,r3 r3 = r0 + r3 = 4 + 0 = 4
str r3,[r4] [r4] = r3, [0x2000] = r3 write 4 to 0x2000
cmp r0,#0 4 != 0
beq to 28 nope, not equal so no branch
sub r0,r0,#1 r0 = 4 - 1 = 3
bl so so this is so(3); pc = 0x1000 lr = 0x1024
so now we enter so for the second time with r0 = 3
stmdb sp!,{r4,lr}
0x7FF0 = r4 (saving from so(4) call but we dont care its value even though we know it)
0x7FF4 = lr from so(4) = 0x1024
sp=0x7FF0
ldr r4,zptr r4 = 0x2000
ldr r3,[r4] r3 = [0x2000] = 4
add r3,r0,r3 r3 = 3 + 4 = 7
str r3,[r4] write 7 to 0x2000
cmp r0,#0 3 != 0
beq 0x1028 not equal so dont branch
sub r0,r0,#1 r0 = 3-1 = 2
bl so pc=0x1000 lr=0x1024
so(2)
stmdb sp!,{r4,lr}
0x7FE8 = r4 from caller, just save it
0x7FEC = lr from caller, 0x1024
sp=0x7FE8
ldr r4,zprt r4=0x2000
ldr r3,[r4] r3 = read 7 from 0x2000
add r3,r0,r3 r3 = 2 + 7 = 9
str r3,[r4] write 9 to 0x2000
cmp r0,#0 2 != 0
beq 0x1028 not equal so dont branch
sub r0,r0,#1 r0 = 2 - 1 = 1
bl 0x1000 pc=0x1000 lr=0x1024
so(1)
stmdb sp!,{r4,lr}
0x7FE0 = save r4
0x7FE4 = lr = 0x1024
sp=0x7FE0
ldr r4,zptr r4=0x2000
ldr r3,[r4] r3 = read 9 from 0x2000
add r3,r0,r3 r3 = 1 + 9 = 10
str r3,[r4] write 10 to 0x2000
cmp r0,#0 1 != 0
beq 0x1028 not equal so dont branch
sub r0,r0,#1 r0 = 1 - 1 = 0
bl 0x1000 pc=0x1000 lr=0x1024
so(0)
stmdb sp!,{r4,lr}
0x7FD8 = r4
0x7FDC = lr = 0x1024
sp = 0x7FD8
ldr r4,zptr r4 = 0x2000
ldr r3,[r4] r3 = read 10 from 0x2000
add r3,r0,r3 r3 = 0 + 10 = 10
str r0,[r4] write 10 to 0x2000
cmp r0,#0 0 = 0 so it matches
beq 0x1028 it is equal so we finally take this branch
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
increment after
r4 = [sp+0] = [0x7FD8] restore r4 from caller
pc = [sp+4] = [0x7FDC] = 0x1024
sp += 8 = 0x7FE0
(branch to 0x1024)(return from so(0) to so(1))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FE0] restore r4 from caller
pc = [sp+4] = [0x7FE4] = 0x1024
sp += 8 = 0x7FE8
(branch to 0x1024)(return from so(1) to so(2))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FE8] restore r4 from caller
pc = [sp+4] = [0x7FEC] = 0x1024
sp += 8 = 0x7FF0
(branch to 0x1024)(return from so(2) to so(3))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FF0] restore r4 from caller
pc = [sp+4] = [0x7FF4] = 0x1024
sp += 8 = 0x7FF8
(branch to 0x1024)(return from so(3) to so(4))
ldr r3,[r4] read 10 from 0x2000
mov r0,r3 r0 = 10
ldmia sp!,{r4,pc}
r4 = [sp+0] = [0x7FF8] restore r4 from caller (main()'s r4)
pc = [sp+4] = [0x7FFC] = 0x708
sp += 8 = 0x8000
(branch to 0x708)(return from so(4) to main())
and we are done.
一个堆栈就像一个迪克西杯架，可能在你的时代之前。一个杯架，您可以在其中拉下一个杯子，然后将下一个杯子和其余杯子留在杯架中，您可以将一个杯子推回那里。
所以堆栈是函数的临时存储，在杯子上写一个数据项，然后将其推入支架（从调用者那里保存 r4）写入另一个项目并将其推入支架（lr，return 来自来电者的地址）。我们在这里每个功能只使用了两个项目，所以每个功能我可以将两个杯子推入支架，每次调用该功能我都会得到两个新的和唯一的存储位置来存储这个本地信息。当我退出该功能时，我将两个杯子从支架上拉下来并使用它们的值（并丢弃它们）。这在某种程度上是递归的关键，堆栈为每次调用提供新的本地存储，与之前对同一函数的调用分开，如果没有别的你需要一个 return 地址（尽管确实做了一些更简单的递归优化后没有的示例足够聪明，基本上可以从中创建一个循环）。
ldr rd,[rn] 认为他 brakets 说的是那个地址的项目，所以读取 rn 中地址处的内存并将该值保存在 rd 中。
str rd,[rn] 一个乱七八糟的 arm 指令作为其余部分 第一个参数是等号的左侧 (add r1,r2,r3 r1 = r2 + r3, ldr r1,[r4] r1 = [r4]) 这个是向后的 [rn] = rd 将 rd 中的值存储到地址 r4 所描述的内存位置，一级间接。
stmdb sp!, 意思是在做任何事情之前将堆栈指针递减 4 字节乘以列表中的寄存器数量，然后将第一个、最低编号的寄存器写入 [sp+0]，然后写入 [sp+4] ] 依此类推，最后一个会比sp的起始值小四。这 ！意味着函数结束时 sp 是该递减值。您可以将 ldm/stm 用于堆栈推送和弹出之外的其他内容。像 memcpy，但那是另外一回事了...
所有这些都在您应该已经拥有的 infocenter.arm.com 的 arm 文档中（arm 体系结构参考手册，如果您还没有阅读，armv5 是首选）。