用汇编语言实现递归

沉宝

本文成篇的起因于社长的一条记录 链接
) L/ O6 O  ^; J, m! S
递归是计算机科学中一种解决问题的重要方法。所谓递归，通俗地说就是自己调用自己，它在很多语言和环境下都可以实现。以社长的工作场景为例，根据爱坛上的信息，大概是两个关键词：Unix和汇编。本人条件有限，只能用Linux模拟，汇编也只限于x86汇编。下面就是用汇编语言编写的，用递归方法计算阶乘的示范程序。
! B6 X6 @% @( v' Q3 J

1. LEN_OF_OUTPUT equ 10
   
2. 
   8 q/ R, x  {1 x  [0 K/ j
3. section .data                           ;
   
4.    userMsg db 'Please enter a single-digit number: ' ;
   
5.    lenUserMsg equ $-userMsg             ;
   
6.    disp1Msg db 'The factorial of '
   : t" S; q1 y$ i  w; ~, r- V
7.    lenDisp1Msg equ $-disp1Msg                 
   ) d7 v' V8 E+ @) h6 X# S, R
8.    disp2Msg db ' is '
   8 M: n. Z3 ]& Y5 G* q
9.    lenDisp2Msg equ $-disp2Msg                 
   
10.    errMsg db 'Wrong input. Only one-digit number can be accepted.',0x0a
    1 K5 [, m& }; h3 K5 W" |  Q  s' x
11.    lenErrMsg equ $-errMsg                 
    4 i( o2 Z; }& ^8 x
12. 
    7 f9 Y% \2 b9 Q$ M: i9 l8 [
13. section .bss           ;
    
14.    num resb 1
    ) _- f' [* }/ A9 Q6 v+ `
15.    result resd 1
    6 Z" R' b! D% q
16.    buffer resb LEN_OF_OUTPUT+1
    8 W- w7 R. {* L6 J+ `% {8 S6 {
17.         
    
18. section .text          ;
    
19.    global _start
    
20.         
    
21. _start:                ;
    5 R: L; Y/ Q. \/ ], s0 l
22.    mov eax, 4
    5 ~% S3 l& M) c1 ?! d7 G0 M# n9 y
23.    mov ebx, 1
    
24.    mov ecx, userMsg
    ( {8 P' U4 U: L) N3 x* k3 n
25.    mov edx, lenUserMsg
    0 h9 M& @8 f) ]2 Q3 O
26.    int 80h
    
27. 
    
28.    ; read user's input
    ' O4 }# g8 m# I7 R2 O: e0 D$ |9 l0 i
29.    mov eax, 3
    2 S6 K4 n0 E* u9 f5 C/ W+ `) T  _
30.    mov ebx, 0
    5 G' E; Z9 E2 y3 h" d7 }  {- j7 A1 ~3 u
31.    mov ecx, num  
    1 x' }! K; P: P) j/ w
32.    mov edx, 1          ; length of input buffer
    
33.    int 80h
    ' D2 K; b5 P* x2 b3 l* |' V( G
34.         
    
35.    mov eax, [num]
    ' O8 c( z/ ?) G( s4 F) y3 ^
36.    and eax, 0xFF
    
37.    sub eax, 0x30
    # H& ^% M' _  \# W1 b0 Q8 ]( z# H6 [
38.    jl ERROR
    4 i& ]8 f4 O3 d; y
39.    cmp eax, 10
    
40.    jl DO_CALC
    ' B; Y4 Y& G6 k( G) w6 j. w- L
41. ERROR:
    6 k$ C) c" w( s# u0 k; [
42.    mov eax, 4
    
43.    mov ebx, 1
    
44.    mov ecx, errMsg
    
45.    mov edx, lenErrMsg
    + `5 X! h5 o; Q: `
46.    int 80h  
    
47.    jmp EXIT
    
48. 
    
49. 
    
50. DO_CALC:
    
51.    call factorial
    
52.     ; The parameter is in eax. After calling, the result will be stored in eax.
    + M7 U0 @# Y, a7 k5 R# i  \
53.    mov [result], eax           ; Save the result
    9 @; R+ S6 D* D9 R" s0 t
54. 
    
55.    ; print result
    
56.    mov eax, 4
    
57.    mov ebx, 1
    
58.    mov ecx, disp1Msg
    ( |2 I2 y: L* i4 _  k3 h
59.    mov edx, lenDisp1Msg
    
60.    int 80h  
    8 |% W( h* h# _: X( r3 K
61.    mov eax, 4
    " s4 H8 B% B& F  [
62.    mov ebx, 1
    
63.    mov ecx, num
    . _( g* _9 c5 H1 X4 r) X8 t
64.    mov edx, 1
    
65.    int 80h
    
66.    mov eax, 4
    % G1 S4 S, G, v$ i* v- n4 C' F, R
67.    mov ebx, 1
    
68.    mov ecx, disp2Msg
    2 }# `: f3 P( D
69.    mov edx, lenDisp2Msg
    2 r* B& R/ y2 o& i% U  B
70.    int 80h  
    # E5 W$ J3 j, F# X8 [
71. 
    . r; J8 s8 t+ l" d- e3 J" W+ ^
72.    ; output number
    
73.    mov eax, [result]           ; VALUE THAT I WANT TO CONVERT AND DISPLAY
    $ L" x  F) [# @2 F# }: D: T) J
74.    mov byte [buffer+LEN_OF_OUTPUT],0x0a
    
75.    lea esi,[buffer+LEN_OF_OUTPUT]
      E. N# l/ z9 e+ n- v
76.    mov ebx,10         
    , b* H. d* N9 u& f# C
77. ASC_LOOP:
    : V4 z8 E) G4 l- a: H' |
78.    mov edx,0            ; clear dx prior to dividing edx:eax by bx
    
79.    div ebx              ;DIV EAX/10
    % t/ n* _0 p4 p( H
80.    add edx,0x30           ;ADD 48 TO REMAINDER TO GET ASCII CHARACTER OF NUMBER
    ) |5 |" ?& m) d' {) \0 P6 M9 b5 s
81.    dec esi              ; store characters in reverse order
    ( l$ Y% d1 b9 R, D+ ?' Z
82.    mov [esi],dl
    
83.    cmp eax,0            
    9 i& g" j' ^& y/ U! Z; e
84.    jz END_ASC             ;IF AX=0, END THE PROCEDURE OF NUMBER TO ASCII
    
85.    jmp ASC_LOOP            ;ELSE REPEAT
      A' ~- q2 o; k" k$ v6 C
86. END_ASC:
    
87.    mov eax, 4
    
88.    mov ebx, 1
    : f8 \4 q) f5 q
89.    mov ecx, esi
    & M' w( r7 [0 k  c
90.    lea edx,[buffer+LEN_OF_OUTPUT+1]
    
91.    sub edx, ecx
    ( n2 ^, w5 _% l& K& W  V
92.    int 80h  
    
93.    
    
94.    ; Exit code
    
95. EXIT:
    / ^% s# G+ z: ^7 J5 y' h/ I0 x# m% T
96.    mov eax, 1
    
97.    mov ebx, 0
    
98.    int 80h
    2 k1 z, h7 r( ^% `3 `3 ]
99. 
    , n3 f, ?- {2 q: @+ N, s) M
100. 
     
101. 
     
102. ; Factorial function using recursion
     : `  b7 B' t" z8 r6 B4 J3 j
103. factorial:
     * N2 \5 T- ~2 R7 G
104.     ; Check if eax is 0 (base condition)
     
105.     cmp eax, 0
     
106.     jz end_recursion
     $ U$ M$ G3 E' U5 ^
107. 
     
108.     ; Save the current value of eax
     
109.     push eax
     
110. 
     / [% p+ `- }0 F
111.     ; Decrement eax and call factorial function recursively
     
112.     dec eax
     * F6 C) c9 l7 Z( m$ a  t
113.     call factorial
     ; }2 G2 A7 z7 J2 V
114. 
     
115.     ; Multiply the result returned in eax with the saved value of eax
     2 p; s# E7 x! l& l
116.     pop ebx
     
117.     imul eax, ebx
     
118. 
     
119.     ret
     
120. 
     
121. end_recursion:
     ( G0 Q& Z" n2 l
122.     ; Return 1 when eax is 0 (base condition)
     7 M6 T. s4 w: X" |7 e
123.     mov eax, 1
     
124.     ret

复制代码

# J3 A* W, L/ T程序在nasm编译器下通过并成功运行。相应的命令行如下，有兴趣的童鞋可以自行验证。
) r2 `9 M' J, W8 d! ]0 o

1. nasm -f elf factorial.asm
   % p; P4 V* Y! T: v  c$ ^% y
2. ld -m elf_i386 -s -o factorial factorial.o
   
3. ./factorial
   

复制代码

由于汇编不擅长处理I/O，所以程序限制输入仅限于一位数字（0-9），以免过于喧宾夺主。其实程序中真正紧扣主题的就最后一小段：
) c* h. @% u3 l, t( ^

1. ; Factorial function using recursion
   % }8 t4 r4 p3 W) r" X
2. factorial:
     k6 W0 l8 s# K5 h% P+ ~* R6 R
3.     ; Check if eax is 0 (base condition)
   
4.     cmp eax, 0
   
5.     jz end_recursion
   ) s: d7 d3 n8 f4 |
6. 
   4 e5 V; S$ H5 {# U$ j  \2 i
7.     ; Save the current value of eax
   / o' j, F3 l; A  O
8.     push eax
   ; O6 y, o9 L4 `/ i1 K8 T$ y
9. 
   
10.     ; Decrement eax and call factorial function recursively
    
11.     dec eax
    
12.     call factorial
    $ y  G9 |3 j3 X
13. 
    # f0 i5 b  \7 Y/ u. |( ]
14.     ; Multiply the result returned in eax with the saved value of eax
    / ^  M/ h0 Y( p/ p2 p3 t* I
15.     pop ebx
    
16.     imul eax, ebx
    ) V: o6 c* z- |) V* D" f1 [2 r
17. 
    : r5 F" F6 J1 |8 x& f
18.     ret
    
19. 
    + c) R/ v: P4 |9 H; i& a
20. end_recursion:
    
21.     ; Return 1 when eax is 0 (base condition)
    
22.     mov eax, 1
    1 M# q7 a2 l" Q9 f# I
23.     ret

复制代码

可以清晰看出函数在其函数体中调用了它本身。

以上证明了汇编语言不是实现递归的障碍。推而广之，所有中低级语言都可以轻松实现递归。某些高级语言反而不能做递归是人为强制规定的，换而言之是原作者权衡利弊的结果。
' {( l# \9 I9 m
世界上没有免费的午餐，递归在编写程序的时候简洁优雅，但运行过程中要付出极大的代价，甚至有可能是灾难。由于是函数反复调用自己，那么所有的中间结果都要暂时保留在栈（stack）上，直到最后一层函数调用完毕才能逐步清除。这既低效，又不安全。栈式计算是一个古老的概念，它与现代的多寄存器和流水线等都格格不入，难以优化提速。递归对栈空间的占用更可怕，占用量与调用函数次数线性相关（套用复杂度的概念就是O(n)），递归次数多了之后，很容易超出栈容量，从而导致栈溢出。具体到社长的工作中可能还有很多实时任务，一大堆高优先级的中断响应程序可不会等着递归函数运行完了再启动，这会让栈空间雪上加霜。想一想某个核电控制程序突然栈溢出了，那场面，哈哈哈。

这可以解释，为什么条件上有可能，但社长很长时间里都没有接触到递归编程。无论用C还是用汇编，都强调的是速度与可靠性。社长实战出发，不需要知道回字的4种写法。至于Python，整个编程思想都变了，Python假定计算机的计算速度远远超过了需求，编程者无需为性能而操心。 Python语言的设计初衷，也不是为关键任务而生，而是想让更多的门外汉用起计算机来。所以在Python程序中容易见到递归。

% B. H8 ~& E$ G& D4 O% l8 F有很多时候，递归用作概念性算法表达。真到了用代码实现的时候，再换用其它方法。比如说将递归转化成迭代（iteration）。

- e* T4 Q$ W: I% E  t5 q' y另外，汇编语言作为一种低级编程语言，在不考虑时间成本的前提下，没有什么是它做不了的。本期课后作业：如何用汇编语言实现继承（Inheritance）和多态（Polymorphism）？请写出示范程序。我们知道继承和多态是面向对象编程（Object-oriented programming）的两个基本点，有了它们就可以实现汇编语言的面向对象编程。

6 G& K! n6 q* G9 ]

马鹿

原来是堆栈或者内存不够用的物理限制呀。
/ Q2 m/ B) z4 t+ n" d
) L+ k. G, @2 g  P  F昨天看了一眼我们用最新的软件（最近10多年都没接触新版的软件， 客户不用）， 最底层还是汇编， 只不过上面加了很多界面， 让使用变得复杂很多。。。

四处张望

fortran我不知道，事实上c以后的高级语言基本没有不能递归调用，当然实际上的确是有堆栈溢出的危险，但是一般来说堆栈溢出其实是一个很好控制的异常，尤其是现代高级语言普遍使用异常之后。只不过生产环境中的代码，的确是很少采用递归，如果有用一般在验证完成后会转换成迭代循环以减少内存使用和提高速度。

pcb

记得有门课叫 compiler
! E, f/ f# L* M( U% Z编译原理？

无言

看标题就感觉是对社长有感而发，果然

晨枫

, S8 G$ G2 h) n7 ^9 [/ [
! ^3 E  }0 N1 L; }没有注意到上下文，也可能理解有误，递归的核心或许可以简单化地理解成后向Goto？
' [, P+ b; K9 I
但我觉得这里面可能有一个基本的分别：一次性执行的离线程序vs反复执行的在线程序。
+ \  [3 O/ G6 d9 @: `  H6 d6 h
( y, X: C$ R4 N8 a; R科学计算基本上都是一次性执行的离线程序，从begin到end一气呵成，所有递归实际上都在这一次执行中完成，所以不正确的递归可以造成死循环，正确的递归也需要完整执行完后才释放所有的中间结果，内存占用太大。不许用递归是有道理的，所以都鼓励用for loop。

+ o& F( P) \  v1 q, E工控计算大多是反复执行的在线程序，比如每秒一次，每一次执行也是从begin到end一气呵成，每次递归只执行“上一次”和“本次”之间的关系，完事了就释放内存。这是有限计算，不是无限计算，不可能死循环，内存占用有限，只需要本次计算有关的加上上次的结果。这样的计算也是很多工控计算的必须。

! r7 @5 v: u" v4 s举一个例子：
  j& l- ]' O  \5 ]+ m! Y) d  N# `" d+ ^
5 N/ L% `4 b$ u; u在科学计算里，计算数值解需要递归计算，最后比较两次计算之间的误差，足够小了就完事，否则接着算，永远不收敛就死循环了。
2 {% H' c' n. w8 e; ]: h
在工控计算里，比如说控制量计算，u(k+1)=f(u(k), additional inputs)，这在每秒一次的程序执行里就是once through，不管前后两次的误差如何，所以没问题，也必须递归，否则没法算。但只要过程还在运行，控制要求还在，还真是无限循环计算的，每秒循环一次。

沉宝

晨枫 发表于 2025-1-18 04:21
# l8 {* h" J4 j7 S( L. g没有注意到上下文，也可能理解有误，递归的核心或许可以简单化地理解成后向Goto？
! k$ v8 |0 _7 G( c, N
  R2 s: R9 ?3 T! `0 C但我觉得这里面可能有一 ...

递归的核心就是严格意义上的自己调用自己。

在计算机程序里面，调用一个函数（或者子程序）与goto来goto去的最大区别是调用函数由系统来负责保持当前环境（例如各个寄存器里面的数值），以便调用返回后无障碍继续运行；而goto则是由程序员决定哪些有用的数据需要保持（比如说存储在全局变量里）。系统保持当前环境的方法是在栈上开辟一块临时空间 ，把系统认为有用的信息都存在那里，函数返回后这块临时空间可以被释放。至于for loop，你可以看成是结构化的goto（goto的一个子集），使用它可以减少人为失误。
) o# q, x3 ~- H# R  b2 @
& X& q+ j* W# L4 g; Y回到递归，如果数学模型定义中有函数调用自身的场景，例如阶乘定义为f(n)=n×f(n-1)，那么递归的方法就是在程序中1:1地按定义编写函数f(x)，这样函数的实现代码中无可避免地需要调用f(x)自身。好处嘛编写程序的时候很省心，代价是麻烦都留给了系统。以晨大的水平，肯定可以写出用for loop计算阶乘的程序，但这只是计算结果上等价，而不能称之为用递归编程，或者说晨大找到了递归的有效替代物。

4 {1 X2 @8 S( ]8 R  Z. h至于在工控计算里，比如说控制量计算，u(k+1)=f(u(k), additional inputs)，你可以看成这是一个广义上的递归。但在具体执行层面，晨大自己也说了，每秒一次的程序执行里就是once through，必须保证在下一秒来临之前完事并释放内存，可能容不得任何递归代码。

5 T( K8 L9 |  q" Z小结，很多时候讨论递归专指是在编程算法层面上的，而非广义或哲学意义上的。哦对了，广义递归还可以举出什么例子？从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事：“从前有座山，山里有座庙，庙里有个老和尚，……’”

晨枫

沉宝 发表于 2025-1-18 13:26
& z" `4 \) z% P) g. Q( c递归的核心就是严格意义上的自己调用自己。
) |3 u$ ~, A$ r$ b6 _5 c! t! f4 Q
9 u# q* w6 J' f- _1 z0 W在计算机程序里面，调用一个函数（或者子程序）与goto来goto ...

明白了。
7 t7 e3 ~' z# ]
( @9 i7 i/ y4 K* d3 o递归要是有一个counter，counter计数到了就自动中止，应该也没有内存溢出问题了吧？

pcb

晨枫 发表于 2025-1-19 04:32
; ~7 i# x8 `0 t5 L) V3 y0 T明白了。
/ ]# B: g$ |8 `& r5 M. D" ^  k- N
8 j* X8 d- B! X3 E$ O% K递归要是有一个counter，counter计数到了就自动中止，应该也没有内存溢出问题了吧？ ...

全局变量

晨枫

pcb 发表于 2025-1-18 15:07
全局变量

嘻嘻，全局变量好啊

沉宝

晨枫 发表于 2025-1-19 04:32
  ?2 b* h7 D. t9 n; v明白了。
' Q4 I+ }4 R* h, C# S0 ^8 L
递归要是有一个counter，counter计数到了就自动中止，应该也没有内存溢出问题了吧？ ...

恰恰相反，按照定义递归常常用别的方法中止，而非counter（启用counter往往说明你正在做非递归化转化过程中）。例如前述阶乘的中止条件就是f(0)=1，程序不知道要运行多久直到遇上该中止条件。这种不确定性会造成运算规模不可控，资源消耗不可控，对于大的输入值内存溢出的风险很高。

晨枫

沉宝 发表于 2025-1-18 17:07
0 J7 I+ g! A7 D恰恰相反，按照定义递归常常用别的方法中止，而非counter（启用counter往往说明你正在做非递归化转化过程 ...

嗯，明白了，还是需要明确的中止条件，只是有时候这个终止条件可以在不确定的未来。

xiejin77

在编程语言的体系中，汇编语言代表着最接近机器的编程方式，它的本质是对机器指令的直接映射。当我们选择使用汇编语言时，实际上是选择了一种与机器进行最直接对话的方式。在这种情况下，引入面向对象编程的概念，如封装、继承和多态，或是应用Java中常见的设计模式，某种程度上违背了选择汇编语言的初衷。打个比方，这就好比让罗士信学习罗成的罗家枪法一样。

6 A5 z( ^* i9 M. }+ n汇编语言的核心价值在于它能让程序员以机器的视角来思考和解决问题。编写汇编代码时，程序员需要直接关注CPU的寄存器操作、内存访问、运算单元的调度以及中断处理等底层细节。这种思维方式与面向对象编程所强调的抽象化、模块化的思维方式存在根本性的差异。当我们在汇编语言中引入面向对象的概念时，不仅会增加不必要的复杂性，还会在一定程度上模糊了对底层硬件的直接控制。
+ }4 V$ J: f/ F, M' ], p3 i4 `
, M- O. u$ c2 G2 M  j# b% M4 X- z( n更重要的是，人们选择使用汇编语言通常是出于对性能的极致追求或者需要直接操作硬件的场景。在这些情况下，面向对象编程固有的运行时开销是不可接受的。封装和继承等特性虽然能提升代码的可维护性和复用性，但这些优势在汇编语言的应用场景中往往显得不那么重要，反而会影响程序的执行效率和实时性能。
$ M: o( A3 x! j! ^: i
保持汇编编程的纯粹性，意味着我们要专注于机器级别的思维方式，将注意力集中在硬件资源的精确控制和优化上。这种专注能够帮助我们写出更高效、更精确的底层代码。当我们需要处理底层驱动、实时系统或性能关键的代码段时，应该充分发挥汇编语言的特长，直接而高效地操控硬件资源，而不是被高级语言的编程范式所束缚。

因此，我个人认为在使用汇编语言时，应当尊重并遵循其最本质的特征：直接性和底层控制能力。只有让我们的思维方式回归到最基础的机器级别，这样才能真正发挥汇编语言的优势，实现最优的性能表现和最精确的硬件控制。