计算机搭建

0 前言

图灵完备（Turing Complete）这款游戏通过主线关卡的任务，引导玩家从逻辑门开始搭建电路，最终搭建出两种架构的可运行计算机，用自己设置的汇编代码实现条件语句、循环语句与函数，并在此基础上完成简单的编程。

这款游戏涉及到的知识有数字电路、计算机组成原理与汇编语言，不过即使没有这些前置知识也是可以玩的，因为游戏会提供知识卡片，较难的关卡也会有所提示。恰好这学期学了数字电路，便去买了这款游戏玩，感觉十分有趣，收获也颇丰。

我不打算展示每一关的解法，网上已经有人做了详细的攻略；在这里，我只想介绍一下使用到的元件、最终搭建的计算机及其汇编语言。一方面这是对游戏总结与知识的回顾，另一方面这份笔记或者说报告也算是一个知识的备忘录。

没有学过计算机组成原理，从零开始搭建的电路也没有系统性地预先设计，所以许多地方可能显得比较笨拙。不过我想，作为第一次尝试已经足够了——让我这个电脑小白了解到了许多知识，也在探索的过程中享受到了游戏的乐趣。

1 使用到的元件

1.1 常用逻辑电路

1.1.1 基本元件

1 逻辑门

基本逻辑门有与门（And Gate）、或门（Or Gate）、非门（Not Gate）、与非门（Nand Gate）、或非门（Nor Gate）、异或门（XOR Gate）、同或门（XNOR Gate），其中由与非门或者或非门均可构造出所有其他的逻辑门。

在实现逻辑门功能的元件中，目前应用最广泛的是 TTL 电路（Transistor-Transistor Logic）与 CMOS 电路（Complementary Metal-Oxide Semiconductor，），其中 TTL 电路的输入引脚悬空则相当于高电平，而CMOS 电路的输入引脚悬空则相当于高阻态。

TTL 电路由双极性三体管组成，CMOS 电路由绝缘场效应管组成，它们都易于制造出 n 位与非门或 n 位或非门，并且一般来说，与非门的性能比或非门更好（速度更快），因此工程实践中一般将逻辑表达式化为最简与非式。

图灵完备这款游戏则采用了另一种做法，将 2 位与门、2 位或门、非门、2 位与非门、2 位或非门视为最基础的逻辑门，它们的延迟都记作 2；异或门、同或门由它们组成，故延迟为 6；3 位的与门、或门、与非门、或非门均由 2 位的逻辑门组成，延迟为 4。这样会导致一些功能的最简电路与 TTL 或 CMOS 电路的实现方案略有差异。

2 三态门

三态门（TSL，Three State Logic）又称为三态缓冲器，在这款游戏中则称为开关。当选通输入端为高电平时，输出等于输入；当选通输入端为低电平时，输出始终为高阻态。

一般来说，两个输出端不能直接相连，否则当输出不同时便会发生短路而烧毁电路。而使用三态门则可以避免这个问题，只需要保证输出端相连的三态门在每个时刻至多只有一个选通。利用这个性质可以实现数据选择器的功能，并且由于输入数量的任意性，由三态门组成的选择器一般比普通逻辑门组成的选择器的元件利用率要高。因此三态门在总线传输中应用十分广泛。

在上一小节中提到了逻辑门的延迟，理论上有延迟就有可能存在竞争与冒险现象。不过这款游戏做了简化，延迟量仅作为衡量电路的指标，而不会产生任何实际的影响，实际上所有门电路都可视为在一瞬间导通。当然在现实生活中，如果需要用三态门组成选择器，则需要考虑这一点，否则不仅可能产生毛刺现象，严重时还可能烧毁电路。

3 延时器

上一小节中说到，该游戏中逻辑门的延迟不会产生任何实际的影响，这也就意味着该游戏并没有做类似 Multisim 或 ModelSim 等软件的仿真，而只在电路发生变化或时钟脉冲到来时，才会更新所有电路的状态。并且更新电路时依据的不是上一个元件的状态，而需要追根溯源到最初的输入端。

这也就意味着，输出端不能连至自身的输入端，即循环依赖，否则理论上程序将陷入死循环。因此当出现循环依赖时，游戏便会报错且禁止运行，甚至无法保存该电路。不过游戏还是用其他方式支持了一类特殊的循环依赖（白名单），即或非门锁存器、与非门锁存器、与或锁存器，由此可以构造出一些电平触发器.

即使如此，大部分触发器与时序逻辑电路仍然无法实现，因为涉及到其他类型的循环依赖。为了弥补这一点，游戏提供了一位延时器，即对于每一个时刻，延时器都会输出前一时刻的输入。因此在更新电路状态时，向前追溯到延时器的输出便可以停止了，从而将其输出连至自身输入时不会产生循环依赖。由此可以构造边沿触发器.

1.1.2 电平触发

1 循环依赖白名单

该游戏的方形输入引脚表示通过延时器连至输出端，而圆形引脚表示不通过延时器。对于不包含延时器的电路，循环依赖会导致程序出现死循环，不过特殊的，游戏考虑并支持了以下三种循环依赖：

循环依赖白名单	逻辑电路与说明
或非门锁存器
与非门锁存器
与或锁存器

2 可实现的触发器

与非门锁存器即基本 RS 触发器，理论上可以与 D 触发器、JK 触发器、T 触发器相互转换。于是我们可以做出同步 RS 触发器、主从 RS 触发器与同步 D 触发器，如下表所示。

可实现的触发器	逻辑电路	引脚图
同步 RSFF
主从 RSFF
同步 DFF

3 不可实现触发器

尽管如此，大部分触发器我们仍然无法实现（如下表所示），因为会涉及到上述锁存器之外的循环依赖，如边沿 D 触发器、同步 JK 触发器、主从 JK 触发器等。

不允许的触发器	逻辑电路
JKFF
TFF

1.1.3 边沿触发

实际上，单个延时器的功能相当于边沿 D 触发器，其 CP 端始终连至全局的可调频率时钟脉冲。而 D 触发器可构造出 RS 触发器、JK 触发器、T 触发器，如下表所示：

边沿触发器	逻辑电路图	引脚图
边沿 DFF
边沿 RSFF
边沿 JKFF
边沿 TFF
边沿 T'FF

需要注意的是，测试上述电路时，改变测试的输入信号后，一般要等待两个时刻才能传到输出，这是因为改变测试用的输入信号时不会立即影响延时器，而需等待一个时刻才能写入延时器，再过一个时刻才能输出。而在实际应用时，改变的输入则会立即写入延时器，因此可以实现边沿触发器的功能。

用上述边沿触发器只能搭建同步时序逻辑电路，不过这对于我们的计算机来说已经足够了——我们只需要实现数码寄存器、同步计数器、栈和脉冲发生器。理论上可以通过改变延时器的延时量，从而实现 2n 分频器。

1.1.4 组合电路

1 译码器

在计算机硬件中，译码器最主要的应用是指令译码与寄存器寻址。

1.1 一位译码器

1.2 三位译码器

可利用一位译码器构成三位译码器，这里直接使用非门搭建。

1.3 六位译码器

这里利用三位译码器和八位开关实现六位译码器。相比于最简与非式电路，这样做增加了 2 延时，但是需要的逻辑门数量大大减少。

1.4 八位译码器

同理，为了简化电路，这里直接使用六位译码器和六十四位开关进行设计。

2 选择器

在计算机硬件中，选择器最主要的应用是实现存储器的读取操作。

1 一位选择器

使用开关比与非门更简：

2 三位选择器

这里利用译码器与开关实现三位选择器：

3 四位选择器

这里利用一位选择器和三位选择器实现四位选择器：

八位选择器类似可得（使用选择器或译码器），由于电路庞大，这里不再列出。

3 比较器

在计算机硬件中，比较器最主要的应用是实现程序跳转的判断。

3.1 判等器电路

为清晰起见，这里先给出 Verilog 代码：

xxxxxxxxxx
6
1
module if_eq(A, B, Y);
2
    input[7:0] A, B;
3
    output Y;
4
    
5
    assign Y = &(A ^ ~B);
6
endmodule

电路如下图所示：

3.2 无符号小于

3.3 有符号小于

有符号数的最高位即符号位，它不表示后七位是否乘上 -1，而表示是否加上 -128，如 1111_1111 表示 -1 而非 -127，这样做看似为负数的表示带来了困难，但实际上 -1 与该二进制数表示的无符号数 255 属于同一个模 256 等价类，这样做不仅便于理解与制造取反器、减法器、除法器等电路，还可以简化有符号小于的逻辑表达式。如果使用乘上 -1 的表示法，则电路图如下：

1.2 算术运算电路

1.2.1 串行并行加法器

加法器有着诸多的应用，如实现计数器、乘法器、除法器等等。

1 全加器电路

2 串行加法器

3 并行加法器

由两片 4 位超前进位并行加法器串联可以实现一字节的加法器：

1.2.2 取反器与减法器

1 一位全减器

全减器的设计与全减器是类似的。为了清晰起见，先给出 Verilog 代码

xxxxxxxxxx
10
1
module FS(A, B, Cin, S, Cout);
2
    input A, B, Cin;
3
    output S, Cout;
4
    wire temp;
5
    
6
    assign temp = B ^ Cin;
7
    assign S = A ^ temp;
8
    assign Cout = (~A & temp) | (B & Cin);
9
    // 优先级由高到低: ~ & |, 因此括号是不必要的;
10
endmodule

引脚图及电路图如下图所示：

2 八位取反器

易知取反加以记为负数。

3 八位减法器

由 $A-B=A+(-B)$$A - B = A + (-B)$ 即得：

1.2.3 移位器与乘法器

1 任意移位器

最直接的思路是罗列所有的情况后，使用开关选取输出（即八选一选择器）。

2 移位器另解

另一种思路是根据每一位的权重进行移位，这种思路将逻辑门的开支从 83 降到了 51，但是延时量从 8 增加到了 12。

3 四位乘法器

利用通用移位器与加法器可以简单地实现乘法器，不过元件利用率较低。

1.2.4 加减器与除法器

1 除法器的思路

计算除法最简单的思路是用被除数反复减去除数，直到被除数小于除数为止，留下的便是余数，减去的次数即位商数。按照这个思路，如果要求在一个时钟脉冲内完成，则需要大量的逻辑门并且延时高；如果使用多个时钟脉冲，则需要大量的时钟刻。无论如何，运算速度很慢，并且对于不同的数据，运算时间差异较大。

另一种思路是使用并行的除法器，即后面两节中将要介绍的，在一个时钟脉冲内完成计算。虽然只需要一个时钟脉冲，但是电路庞大，一字节的除法器便需要上千个逻辑门，延时量也高达上百，无论是逻辑门数量，还是延时量，都与一个简易的 8 位计算机差不多了。

第一类思路主要是从软件（程序）上实现的，优化的思路是使用二分法；第二类思路主要是从硬件上实现的，优化的思路是并行改为串行；还有一类折中的思路，用若干时钟脉冲和较低的延时量实现除法器，这里不做介绍。

2 可控加减法器

为了实现不恢复余数的除法器，需要使用到可控加减法器，引脚图、电路图与电路说明如图所示：

自定义元件的引脚与形状是根据内部电路图自动生成的，这就是我如上排版的原因。为了使得下一小节的电路图看着更简便、更紧凑，我修改了很多遍可控加减法器的电路布局及其引脚分配，最终得到了下一小节中除法器的电路图，看着还是很舒服的。

3 一字节除法器

以无符号的八位并行除法器为例，电路图如下图所示：

其中加减法电路仍为串行，因此可以使用并行加减法电路进一步降低延时量。

1.3 时序逻辑电路

1.3.1 数码寄存器

1 八位寄存器

延时器及 D 触发器，由 D 触发器可实现数码寄存器：

对于八位的情况，分别存储每一位即可：

2 改进寄存器

在八位寄存器的基础上，可增加始终读取端以方便使用，如下图所示：

3 存储四字节

思路一：始终读取数据，使用选择器选出需要的数据。这种思路虽然可以压缩空间，但是对于始终读取数据并不是一个好主意。如果将存储数据的不是寄存器，而是外部的输入输出，那么我们将无法延迟读取数据。

思路二：注意到寄存器在不读取数据时，输出为高阻态，于是可以只在输入端使用开关。这个思路虽然比思路一多用了一个逻辑门，但是可以进一步压缩空间，而且并非始终读取数据，通用性更强。

1.3.2 加法计数器

1 用加法器搭建计数器

最简单的思路是用寄存器、加法器和数据选择器实现计数器及其置数功能：

2 用触发器搭建计数器

可用 JK 触发器实现四位二进制计数器 74161，其中 JK 触发器由 D 触发器（即延时器）搭建。

3 串联芯片八位计数器

由两片四位二进制计数器 74161 级联，可得到八位二进制计数器：

相比于由寄存器、加法器和数据选择器搭建的方案，这样做的好处是逻辑门数量少、延时量低。

1.3.3 脉冲发生器

脉冲发生器用于实现程序指令的顺序读取。这里以周期为 16 的 8 位输出脉冲发生器为例，用四位数据选择器和四位二进制加法计数器 74161 实现，电路如下图所示：

实际上，这就实现了 8 位操作系统位宽、4 位控制存储器地址的程序指令顺序读取。

1.3.4 压栈与弹栈

为了实现栈，首先需要存储空间，这里直接使用 256 字节的随机存储器（RAM），利用加减计数器和延时器（D 触发器）实现。其中 RAM 可由数据选择器实现。

2 计算机的硬件

2.1 计算机

2.1.1 计算机的介绍

在第一小节中，我将介绍一般的计算机的硬件结构。

1 计算机的体系

1.1 冯诺依曼结构

“计算机之父” 约翰·冯·诺依曼在 1945 年的报告《First Draft of a Report on the EDVAC》中提出了冯诺依曼体系结构，其基本原则是：

1. 采用二进制逻辑，以简化计算机的设计；

2. 程序存储执行，以提高存储容量与运算速度；

3. 计算机由五个部分组成：运算器、控制器、存储器、输入设备、输出设备。

其中程序分为指令和数据，统一存储在控制存储器中，使用的时候依次读取，或指定一次读取的程序中哪一部分是指令、哪一部分是数据。

1.2 哈佛结构

哈佛结构是在冯诺依曼结构的基础上，将程序中的指令和数据分开存储，使用的时候分别读取，其结构复杂，但是有利于提高存储器带宽、数据吞吐率和架构稳定性。

中央处理器（CPU，Central Processing Unit）由运算器、控制器和输入输出设备组成。冯诺依曼结构计算机主要由 CPU 和程序存储器组成，哈佛结构的计算机则分为 CPU、程序存储器和数据存储器。

2 计算机的功能

2.1 取出指令

取指（IF，Instruction Fetch）即将一条指令从主存储器取到指令寄存器的过程。

具体来说，以程序计数器（PC，Programmer Counter）的输出作为主存储器的地址读取数据，当一条指令被取出之后，程序计数器中的数值将根据指令字长度自动递增。

2.2 指令译码

指令译码（ID，Instruction Decode）即取出指令后，通过指令译码器对指令进行拆分和解释，识别指令类型和操作数。

2.3 执行指令

执行指令阶段（EX，Execute），通过算术逻辑等单元具体实现指令的功能。

2.4 访存取数

访存取数阶段（MEM，Memory），即访问存储器、取出地址中的具体数据。指令译码后得到操作数在主存中的地址，从主存中读取该操作数用于运算。部分指令不需要访问主存，则可以跳过该阶段。

2.5 结果写回

结果写回阶段（WB，Write Back），一般在执行指令、对数据运算之后，需要将运行的数据结果写回存储器，一般为 CPU 的内部存储器中，以便被后续的指令快速地读取；有些指令的运行结果则写入程序计数器，以控制程序的运行流程。

3 计算机的组成

3.1 控制器

一般来说，控制器由程序状态寄存器、系统状态寄存器、程序计数器、指令寄存器、指令译码器等组成。控制器主要完成取出指令、指令译码与结果写回的功能。

具体来说，由程序计数器提供地址，从控制存储器中取出指令，并进行译码，从而调用运算器，最后将运算器的结果写回存储器。若写回 CPU 内部寄存器，则可用于后续计算；若写回程序计数器中，则得以控制程序流程。

3.2 运算器

一般来说，运算器由算术逻辑单元、中间寄存器、运算累加器、描数字寄存器、B 寄存器等组成。运算器主要完成执行指令和访存取数的功能。

具体来说，根据指令译码结果，从 CPU 内部存储器（高速缓冲存储器）中取出操作数，并进行相应的算术逻辑运算，如与、或、非、异或、同或、加、减、乘、除、取余、移位等。

3.3 存储器

存储器可以根据地址存储或读入数据，有多种分类方式：

1. 按存储介质：半导体存储器、磁表面存储器（如磁盘、磁带）；

2. 按存取方式：随机存储器、顺序存储器、半顺序存储器；

3. 内容可变性：只读存储器（ROM）、随机读写存储器（RAM）；

4. 信息易失性：易失性存储器、非易失性存储器；

5. 系统中位置：内部存储器、外部存储器；

6. 系统中作用：主存储器、高速缓冲存储器、辅助存储器、控制存储器。

3.4 适配器

适配器可将输入的各种类型的数据转为二进制数据，将输出的二进制数据转为十进制、字符串、图象、声音等其他类型数据。

2.1.2 计算机的设计

1 完整电路图

2 总体的介绍

2.1 系统总线

1. 上方的若干条横向蓝线为控制总线（CB，Control Bus），用于从控制单元传输程序指令；

2. 中间的若干条竖向蓝线为数据总线（DB，Data Bus），用于向计算单元传输存储数据。

3. 右侧的若干条竖向蓝线为地址总线（AB，Address Bus），用于在指定 RAM 中读写数据。

2.2 控制器

1. 左上角为程序计数器（PC，Program Counter）；

2. 中上侧为指令译码器（ID，Instruction Decoder）；

2.3 运算器

中间偏右蓝色总线包围的部分均为运算器，其中：

1. 左上角为逻辑运算单元（Logic Unit）；

2. 右上角为算术运算单元（Arithmetic Unit）；

3. 左下角位无符号数值判断单元（Unsigned Condition Unit）；

4. 右下角为有符号数值判断单元（Signed Condition Unit）；

2.4 存储器

最右侧一列为存储器，从上往下依次为：

1. 256 B 快速存储器；

2. 64 KB 快速存储器；

3. 64 KB 控制台存储器；

4. 两个 256 B 的栈。

2.5 适配器

1. 中下方的红色元件为一字节输入输出设备；

2. 左侧上方为关卡显示屏，提供游戏可视化信息，本质上不属于该计算机；

3. 左侧下方为控制台的显示屏，实时显示控制台存储器中的内容；

4. 右下角为声输出设备。

2.1.3 计算机的性能

1 架构分析

1. 该计算机为冯诺依曼体系（即指令与数据位于同一个存储器中）、LEG 架构；

2. CPU 的字长为 32 位，其中前 8 位为操作码，后 24 位为地址码；

3. 数据总线宽度：16 位用于运算器从存储器中取数，8 位用于写回数据；

2 开支分析

1. 最大延时量：568，理论上最大延时量直接影响了 CPU 工作频率的上限；

2. 逻辑门数量：3302019，绝大部分来自快速随机存储器；

3. CPI：即执行一条指令所需的平均时钟周期数，这里严格为 1，不过有些功能（如函数的返回、一字节乘法）需要两条指令才能完成；

3 存储性能

1. 高速缓冲存储器容量：6 字节，可直接寻址，且向运算器传输数据只需一个时钟周期；

2. 内部存储器的总容量：128.75 KB，可直接寻址，但向运算器传输数据需要两个时钟周期；

3. 存储器带宽：存储器的位宽均为 8 位，因此带宽在数值上等于 CPU 频率；

4 其他说明

1. CPU 工作频率可直接在仿真时设置，因此在这里没有参考价值；

2. 吞吐量、利用率、响应时间、CPU 执行时间等参数不便计算，故略；

3. 目前只支持定点运算（加减乘除取余等），不支持浮点操作；

可见，目前该计算机十分简陋，性能并不好，在第四节中我将讨论可能的改进方向。

2.2 控制器

2.2.1 宽指令程序

1 逻辑电路

2 电路说明

上图中的 PROGRAM 元件的介绍见 2.4.1 控制存储器，这里只介绍其它部分：

1. 左侧中间的元件是为 64 位程序计数器（PC），其输出作为地址在控制存储器读取程序数据，每个时钟周期内取出指令与数据，并使地址加一，从而实现程序流程的顺序执行；

2. 如果只有程序计数器和 8 位字长的控制存储器，那么我们只能实现 8 位的 CPU。这里在此基础上，通过译码器和寄存器，在 $4n+1,4n+2,4n+3(n\in \mathbb{N})$$4n + 1, 4n + 2, 4n + 3\ (n \in \N)$ 时刻存储数据，在 $4n(n\in {\mathbb{N}}^{+})$$4n\ (n \in \N^+)$ 同时输出四个字节的数据，从而得到字长为 32 位的宽指令；

3. 上述电路图仅做原理性说明，实际是图中的控制存储器已经集成了宽指令的功能，只需要将程序计数器的步长设置为 4，便可以从控制存储器右上方的四个引脚直接得到宽指令；

4. 最后得到的宽指令中，第一个字节为操作码，用于指定运算的类型；后三个字节均为地址码，其中前两个地址码一般用于指定前两个操作数的寄存器地址，第三个地址码一般用于指定运算器输出结果写回的寄存器地址。

2.2.2 指令译码器

1 操作码译码

1 逻辑电路图

1.2 总线的说明

1. 图中最上方的一条横向蓝线为操作码的总线，经分线器拆成八个一位数据；

2. 图中左上角操作码下方的三条数据线，分别位参数一、参数二和参数三的地址码；

3. 图中左下角的五条竖线位数据总线，左边三条分别是从寄存器中读出的参数一、参数二和参数三。

1.3 前两位操作码

操作码中最高的两位，即 [7:6]，表示立即数。

1. 若操作码的第 7 位为 0，则使用寄存器中的数据，否则为立即数模式，利用左上角的开关将参数一改为指令中相应的地址码。最后的数据输出到第四条数据总线中。

2. 操作码的第 6 位同理，最后的数据输出到第五条数据总线中。

3. 参数三一般不支持立即数模式。

1.4 后六位操作码

操作码的中间三位，即 [5:3]，表示运算的类型；后三位，即 [2:0]，表示具体的运算

1. 若中间三位为 000，则为逻辑运算单元，后三位的说明见 2.3.1 逻辑运算单元；

2. 若中间三位为 001，则为算术运算单元，后三位的说明见 2.3.2 算术运算单元；

3. 若中间三位为 100，则为无符号条件判断单元，后三位的说明见 2.3.3 条件判断单元；

4. 若中间三位为 101，则为有符号条件判断单元，后三位的说明见 2.3.3 条件判断单元；

5. 若中间三位为 010，则为从存储器中读取数据，后三位的说明见 2.4 存储器；

6. 若中间三位为 110，则为向存储器中写入数据，后三位的说明见 2.4 存储器；

7. 中间三位为 011 和 111 的指令暂未设置，为空。

2 地址码译码

2.1 逻辑电路图

2.2 线路的说明

1. 最上方的四条横向蓝线为控制总线

   1. 第一条为操作码，用于指定指令的具体运算；

   2. 第二条和第三条为参数一和参数二，用于指定操作数一和操作数二；

   3. 第三条为参数三，用于指定结果写回的寄存器地址。

2. 上方的两条横向黄线分别为操作码第 7 位和第 6 位，高电平说明为立即数模式，禁用译码器。

2.3 地址码说明

目前只使用到了每个字节后三位的地址码：

1. 000 - 101 分别位六个一字节数码寄存器的地址；

2. 110 位程序计数器的地址；

3. 111 位输入输出设备的地址。

若增加使用前五位地址码，则可以增加 248 个一字节寄存器（高速缓冲寄存器）.

2.2.3 计数器读写

1 逻辑电路

2 线路说明

1. 图中左侧六条竖线中，前两条、中间两条、后两条，分别为参数 1~3 地址码的译码结果后两位；

2. 左下方的三条横线中，上方为程序计数器的输出，中间为程序计数器的置数使能端，下方为程序计数器的置入数据；

3. 中间两个一位开关右侧的两条竖线用于控制寄存器的读写（这一部分未用到）；

4. 再右侧一条蓝线，为运算器结果数据写回的总线；

5. 最右侧三条蓝线，分别是用三个参数的地址码从寄存器或计数器或输入端读取的数值；

6. 右上角的两条横向黄线，上面一条为无符号条件判断的输出数据线，下面一条为有符号条件判断的输出数据线。

3 功能说明

1. 地址码的参数 1~3 可控制是否读入程序计数器的数据；

2. 如果操作码的中间三位表示无符号判断，并且相应的判断结果为真，则向计数器中写入地址码的参数三对应寄存器中的数值；

3. 如果操作码的中间三位表示有符号判断，并且相应的判断结果为真，则向计数器中写入地址码的参数三（是一个地址）。

2.3 运算器

2.3.1 逻辑运算单元

1 逻辑电路

2 线路说明

1. 左侧的两条竖向蓝线为输入数据总线

   1. 第一条线为参数一，第二条线为参数二；

   2. 在普通模式下传输地址码对应寄存器中存储的值；

   3. 在立即数模式下直接传输地址码的地址数据；

2. 中间的八条竖向黄线属于控制总线

   1. 具体来说，这八条线是操作码后三位的译码结果；

   2. 用于控制逻辑运算单元中选取哪一路运算结果作为输出；

3. 右侧的一条竖向蓝线为输出数据总线

   1. 任何时候，有且仅有一路数据输出到该总线中；

   2. 在该电路图之外，还有一个控制器，当且仅当操作码中间三位为 000（即逻辑运算单元）时，才会将该输出数据总线中的数据写回参数三对应地址的寄存器中。

3 功能说明

当操作码中间三位为 000 时，启用逻辑运算单元。操作码后三位及其功能分别为：

其中逻辑门均为八位按位操作，异或、与非、或非、同或由与、或、非实现。

2.3.2 算术运算单元

1 逻辑电路

2 线路说明

见逻辑运算单元的线路说明，唯一不同的是，当且仅当操作码中间三位为 001 时，才会启用算术运算单元的输出。

3 功能说明

2.3.3 条件判断单元

1 逻辑电路图

2 线路说明

1. 左侧两条蓝色竖线和中间两条蓝色竖线完全相同，均为输入数据总线

   1. 第一条线为参数一，第二条线为参数二；

   2. 在普通模式下传输地址码对应寄存器中存储的值；

   3. 在立即数模式下直接传输地址码的地址数据；

2. 左边八条黄色竖线和右边八条黄色竖线完全相同，属于控制总线

   1. 具体来说，这八条线是操作码后三位的译码结果；

   2. 用于控制条件运算单元中选取哪一路运算结果作为输出；

3. 下侧两条黄色横线为输出数据总线

   1. 任何时候，有且仅有一路数据输出到该总线中；

   2. 当且仅当操作码中间三位为 100 时启用第一条黄线；

   3. 当且仅当操作码中间三位为 101 时启用第二条黄线；

4. 条件判断单元的数据写回及其功能见 2.2.3 计数器读写.

3 无符号条件判断单元

4 有符号条件判断单元

2.4 存储器

2.4.1 控制存储器

说明：

1. 图中的 PROGRAM 元件即为控制存储器（CU，Control Unit），用于存储程序，包括指令和数据。

2. 控制存储器本质上为数据选择器，通过左上角的引脚输入地址，作为控制端选择对应地址的数据作为输出。

3. 控制存储器一般为只读存储器（ROM，Read-Only Memory），这里的字长为 8 位，内存为 256 字节（实际上最大为 64 KB，但我只用到了 256 字节）。

4. 特殊的，在该游戏中，可以通过右上角的按钮编辑程序、添加汇编别名、监视各种存储器的状态等。

2.4.2 高速缓存器

1 寄存器寻址

CPU 内部可由地址码直接寻址的寄存器称为高速缓存寄存器，具体说明见 2 地址码译码，这里寄存器寻址只用到了地址码后三位译码结果的低六位。

2 寄存器读写

2.1 逻辑电路图

以一号寄存器为例，其逻辑电路图如下图所示：

2.2 元件说明

中间的倒三角形元件为一字节寄存器

1. 左上角的引脚有效时，读取寄存器中保存的数据；

2. 左边中间的引脚有效时，向寄存器中写入数据；

3. 左下角的引脚为待写入的数据；

4. 右侧的引脚为读取数据时的输出端，不读取数据时为高阻态。

2.3 线路说明

1. 右侧三条蓝色竖线为数据总线，分别对应参数一、参数二和参数三；

2. 数据的读取

   1. 左侧的或门对应的三条线路，分别为三个参数的译码结果，即当某一参数的地址指向该寄存器时，启用寄存器的读取端；

   2. 上方三条黄色横线也是三个参数的译码结果，当读取端为高电平时，通过控制开关的使能端，向相应的数据总线传输数据。

3. 数据的写入

   1. 最下方的倒数第一条黄色横线表示参数一的译码结果，当从随机存储器中读取数据时，左侧的黄色竖线为高电平，向参数一的地址指向的寄存器中写入数据；

   2. 最下方的倒数第二条黄色横线表示参数三的译码结果，通过算术逻辑单元运算时，右侧的黄色竖线为高电平，向参数三的地址指向的寄存器中写入数据。

2.4.3 随机存储器

1 单字节地址

1.1 逻辑电路图

1.2 总线说明

1. 左边四条蓝色竖线为控制总线：

   1. 第一条线为指令码；

   2. 第二、三条线分别为操作数一和操作数二（即参数一和参数二地址指向的寄存器中保存的数值；或者在立即数模式下，直接传输地址）；

   3. 第四条线为参数四，是一个地址，用于指定使用的随机存储器。

2. 右侧的蓝色竖线为输出数据总线。

1.3 元件说明

高速随机存储器（Fast RAM）的原理与 2.4.1 控制存储器的原理类似。

1. 元件性能

   1. 普通的随机存储器存储容量与逻辑门数量相等，但是延迟高，延迟量也等于逻辑门数量；

   2. 高速随机存储器使用十倍的逻辑门数量，可将延迟量降为 10；

   3. 高速随机存储器几乎是所有访存设备中读写速度最快的。

2. 元件功能

   1. 左上角第一个引脚高电平时，读取数据至输出端；

   2. 左上角第二个引脚高电平时，将输入数据保存至相应地址中；

   3. 左上角第三个引脚为八位的地址；

   4. 左上角第四个引脚为八位的输入数据；

   5. 右上角的引脚用于输出数据，当读取使能端为低电平时，输出引脚为高阻态。

1.4 功能说明

1. 操作码后六位

   1. 为 010 000 时，从高速随机存储器中读取地址为操作数二的数据，并将其写入操作数一指定的寄存器中；

   2. 为 110 000 时，向高速随机存储器写入操作数一指定的寄存器中保存的数据，地址由操作数二指定。

2. 操作数三：用于指定一字节地址高速随机存储器，图中的 RAM 对应于 0000 0000。理论上可以有 $2^8=256$$2^8 = 256$ 个 RAM，不过这样做并不方便，于是在下一小节中我们直接使用双字节地址。

3. 实际功能

   1. 增加存储空间，从而可以实现更多的功能；

   2. 便于实现数组（用一个寄存器保存 RAM 中数组的起始地址）。

2 双字节地址

2.1 逻辑电路

2.2 总线说明

同单字节地址，只不过这时操作数三不再是地址，而是该地址指定的寄存器中保存的数据。即我们不再手动指定 RAM 的编号，而是在一个 RAM 里通过两字节的地址直接读写数据，此时一个 RAM 的内存为 64 KB。

2.3 功能说明

1. 操作码后六位

   1. 为 010 001 时，从高速随机存储器中读取数据，并将其写入操作数一指定的寄存器中；

   2. 为 110 001 时，向高速随机存储器写入操作数一指定的寄存器中保存的数据；

2. 操作数一：用于指定高速缓冲寄存器的地址；

3. 操作数二和操作数三：用于指定高速随机存储器的地址。

3 控制台存储

3.1 逻辑电路

3.2 功能说明

1. 在结构上与上一小节中的高速随机存储器完全相同；

2. 只不过这里存储的数据是用于在控制台中显示的 ASCII 码数据。

3.3 操作码说明

1. 当操作码后六位为 010 010 时，从 RAM 中读取数据；

2. 当操作码后六位为 110 010 时，向 RAM 中写入数据。

4 压栈与弹栈

4.1 逻辑电路

4.2 总线说明

1. 左边四条蓝色竖线为控制总线：

   1. 第一条线为指令码；

   2. 后三条线分别为操作数 1~3（即参数 1~3 的地址指向的寄存器中保存的数值；或者在立即数模式下，直接传输地址）；

2. 右侧的蓝色竖线为输出数据总线。

3. 左下方的两条黄线用于在弹栈时控制寄存器的数据写入。

4.3 元件说明

栈的逻辑电路见 1.3.4 压栈与弹栈. 这里只介绍其引脚功能：

1. 左上角第一个引脚为高电平时，弹栈（POP），即将最新输入的数据输出，并删除该数据；

2. 左上角第二个引脚为高电平时，压栈（PUSH），即保存数据；

3. 左上角第三个引脚为数据的输入端；

4. 右侧的引脚为数据的输出引脚，当弹栈引脚为低电平时，输出引脚为高阻态。

4.4 功能说明

1. 操作码后六位

   1. 为 010 011 时，启用第一个栈（用于保存函数的地址）；

   2. 为 010 100 时，启用第二个栈（用于保存函数改写的寄存器中的原始数据）。

2. 操作数一

   1. 后两位为 01 时，为弹栈；

   2. 后两位为 10 时，为压栈；

3. 操作数二：即栈的输入数据。

2.5 适配器

2.5.1 输入与输出

1 逻辑电路

2 电路说明

1. 线路与高速缓冲寄存器几乎相同，这里不再重述；

2. 唯一不同的是，左上角多了一个一位开关，用于在不读取输入时关闭输入使能端。寄存器不需要这个元件，因为即使不需要，正常读取也无妨，但是输入端并非存储一字节，同一数据不能反复读取，而只能读取下一字节的数据；

3. 最下方的连个与门和开关，用于控制各个寄存器和输入输出设备的使能端；

2.5.2 控制台设备

1 控制台介绍

1. 功能：控制台可将指定 RAM 中的二进制数据按 ASCII 码表译码后显示；

2. 存储器：见 3 控制台存储。

2 示例代码

见 4 其他适配器。

3 示例视频

2.5.3 声输出设备

1 逻辑电路

2 线路说明

1. 左侧第一条蓝色竖线为控制总线中的操作码；

2. 左侧后三条蓝色竖线为数据总线，分别为操作数 1~3。

3 功能说明

1. 当操作码后六位为 110 011 时，启用声音设备；

2. 操作数一为声音设备的命令

   1. 为 0 时，表示无操作；

   2. 为 1 时，表示播放；

   3. 为 2 时，表示重置并播放；

   4. 为 3 时，表示停止播放；

3. 操作数二表示音符编号；

4. 操作数三表示音高偏移量。

3 计算机的指令

3.1 指令系统与汇编语言

3.1.1 运算符的汇编别名

这里记操作数一为 $ A $，操作数二为 $B$$B$，操作数三为 $C$$C$

1 逻辑运算符

从下述例子中可见，只用与非门实现其他基本逻辑门，至多需要 5 个时钟脉冲和 2 个单位的存储空间。注意每一条指令都必须是四字节的。

xxxxxxxxxx
44
1
# 用与非门实现其他逻辑运算
2
const A r0
3
const B r1
4
const temp1 r2
5

6
cp in _ A   # 从输入读取数据至 A, 其中 _ 表示 0
7
cp in _ B   # 从输入读取数据至 B
8
# 如果定义 to = 0, 那么上式可写为 cp in to A
9
# 看着更接近自然语言了, 但太多的汇编别名也不是好事
10

11
# and gate: 2 ticks, 1 temp
12
nand A B temp1
13
nand temp1 temp1 out
14

15
# or gate: 3 ticks, 2 temps
16
nand A A temp1
17
nand B B temp2
18
nand temp1 temp2 out
19

20
# not gate: 1 tick, 1 temp
21
nand A A out
22

23
# xor gate: 5 ticks, 2 temps
24
nand A A temp1
25
nand temp1 B temp2
26
nand B B temp1
27
nand temp1 A temp1
28
nand temp1 temp2 out
29

30
# nand gate: 1 tick, 1 temp
31
nand A B out
32

33
# nor gate: 4 ticks, 2 temps
34
nand A A temp1
35
nand B B temp2
36
nand A B temp1
37
nand temp1 temp1 out
38

39
# xnor gate: 5 ticks, 2 temps
40
nand A A temp1
41
nand B B temp2
42
nand temp1 temp2 temp1
43
nand A B temp2
44
nand temp1 temp2 out

2 算术运算符

例子：

xxxxxxxxxx
23
1
const A r0
2
const B r1
3
const temp r2
4

5
cp in _ A   # 从输入读取数据至 A
6
cp in _ B   # 从输入读取数据至 B
7

8
# 下二式等价
9
div+_i A 2 out
10
shr+_i A 1 out
11

12
# 下二式等价
13
mod+_i A 2 out
14
and+_i A 1 out
15

16
# 上式与下二式等价
17
shl+_i A 7 temp
18
shr+_i temp 7 out
19

20
# 第一式与后二式等价 (负数)
21
sub+i_ 256 A out
22
not A _ temp
23
add+_i temp 1 out

3.1.2 条件判断汇编别名

1 无符号条件判断

说明：无符号条件判断在跳转时，程序计数器的地址改写为参数三（是一个地址）。

2 有符号条件判断

说明：

1. 有符号条件判断在跳转时，程序计数器的地址改写为操作数三，即参数三地址指向的寄存器中存储的数据。

2. 这里没有给有符号条件判断添加汇编别名，不过可以用无符号条件判断的汇编别名加上 signed 得到，如 if_eq+signed r0 r1 label_1。

3.1.3 其他类型汇编别名

1 立即数模式

例子：

xxxxxxxxxx
6
1
cp+i_ 1 _ r0                    # r0 = 1;
2
label test
3
    add r0 r0 r0                # r0 *= 2;
4
    sub+i_ 256 r0 r0            # r0 = 256 - r0, 即 r0 = -r0;
5
    if_ne+signed+_i r0 3 test   # 有符号数 r0 不等于 8 时, 重复上述循环
6
# end_test

2 地址码寻址

3 其他存储器

例 1：

xxxxxxxxxx
17
1
const addr0 r0  # 低位地址
2
const addr1 r1  # 高位地址
3
const temp r2   # 暂时存储
4
const number 5  # 读取数量
5

6
label write_data                        # 开始从输入读取数据，并写入内存
7
    write+ram1 in addr1 addr0           # 从输入读取数据并写入 ram1
8
    add+_i addr0 1 addr0                # 低位地址加一
9
    if_ne+_i addr0 number write_data    # 直到写入 5 个数据才结束循环
10
# end_write_data
11

12
cp+i_ 0 _ addr0                         # 将地址重置为零
13
label read_data                         # 开始从内存读取数据，并依次输出
14
    read+ram1 out addr1 addr0           # 从 ram1 读取数据并输出
15
    add+_i addr0 1 addr0                # 低位地址加一
16
    if_ne+_i addr0 number read_data     # 直到读取 5 个数据才结束循环
17
# end_read_data

例 2：

xxxxxxxxxx
6
1
stkpar push in _    # 入栈 1
2
stkpar push in _    # 入栈 2
3
stkpar pop _ out    # 出栈 2
4
stkpar push in _    # 入栈 3
5
stkpar pop _ out    # 出栈 3
6
stkpar pop _ out    # 出栈 1

4 其他适配器

下述例子可以向控制台输出 Hello World 等信息，注意还需要预先定义 ASCII 码表，见。效果见 3 示例视频。

xxxxxxxxxx
67
1
const addr0 r0
2
const addr1 r1
3
const temp r2
4

5
cp+i_ 0 _ addr0
6
cout+i_ ch_H        addr1 addr0 add+_i addr0 1 addr0
7
cout+i_ ch_e        addr1 addr0 add+_i addr0 1 addr0
8
cout+i_ ch_l        addr1 addr0 add+_i addr0 1 addr0
9
cout+i_ ch_l        addr1 addr0 add+_i addr0 1 addr0
10
cout+i_ ch_o        addr1 addr0 add+_i addr0 1 addr0
11
cout+i_ ch_space    addr1 addr0 add+_i addr0 1 addr0
12
cout+i_ ch_w        addr1 addr0 add+_i addr0 1 addr0
13
cout+i_ ch_o        addr1 addr0 add+_i addr0 1 addr0
14
cout+i_ ch_r        addr1 addr0 add+_i addr0 1 addr0
15
cout+i_ ch_l        addr1 addr0 add+_i addr0 1 addr0
16
cout+i_ ch_d        addr1 addr0 add+_i addr0 1 addr0
17
cout+i_ ch_excla    addr1 addr0 add+_i addr0 1 addr0
18

19
cp+i_ 0 _ temp
20
label wait_1
21
    add+_i temp 1 temp
22
    if_ne+_i temp 10 wait_1
23
# end wait_1
24

25
label bs_chars_1
26
    sub+_i addr0 1 addr0
27
    cout+i_ 0 addr1 addr0
28
    if_ne+_i addr0 5 bs_chars_1
29
# end bs_chars_1
30

31
cp+i_ 80 _ addr0
32
cout+i_ ch_S        addr1 addr0 add+_i addr0 1 addr0
33
cout+i_ ch_l        addr1 addr0 add+_i addr0 1 addr0
34
cout+i_ ch_e        addr1 addr0 add+_i addr0 1 addr0
35
cout+i_ ch_e        addr1 addr0 add+_i addr0 1 addr0
36
cout+i_ ch_p        addr1 addr0 add+_i addr0 1 addr0
37
cout+i_ ch_C        addr1 addr0 add+_i addr0 1 addr0
38
cout+i_ ch_l        addr1 addr0 add+_i addr0 1 addr0
39
cout+i_ ch_o        addr1 addr0 add+_i addr0 1 addr0
40
cout+i_ ch_u        addr1 addr0 add+_i addr0 1 addr0
41
cout+i_ ch_d        addr1 addr0 add+_i addr0 1 addr0
42
cout+i_ ch_excla    addr1 addr0 add+_i addr0 1 addr0
43

44
cp+i_ 0 _ temp
45
label wait_2
46
    add+_i temp 1 temp
47
    if_ne+_i temp 10 wait_2
48
# end wait_2
49

50
label bs_chars_2
51
    sub+_i addr0 1 addr0
52
    cout+i_ 0 addr1 addr0
53
    if_ne+_i addr0 80 bs_chars_2
54
# end bs_chars_2
55

56
cp+i_ 5 _ addr0
57
label bs_chars_3
58
    sub+_i addr0 1 addr0
59
    cout+i_ 0 addr1 addr0
60
    if_ne+_i addr0 0 bs_chars_3
61
# end bs_chars_3
62

63
cp+i_ 0 _ temp
64
label wait_3
65
    add+i_ temp 1 temp
66
    if_ne+_i temp 10 wait_3
67
# end wait_3

3.2 流程控制与图灵完备

3.2.1 跳转语句代码模板

我们已经可以通过控制器和运算器向寄存器中读取数据、进行运算并写入数据了，如果可以实现程序的跳转，则该计算机具有图灵完备性。不过准确来说，图灵机要求内存无限，而我们只能实现有限的内存，因此实际上实现的是有限下推自动机（Push-down Automata）。

程序计数器以输出数据为地址，使控制存储器顺序输出程序指令。该计算机提供了三种控制程序流程的方式：

1 直接写入计数器

xxxxxxxxxx
8
1
# 法一
2
cp in _ cnt         # 直接将输入数据写入计数器
3
cp r0 _ cnt         # 直接将寄存器的数据写入计数器
4

5
# 法二
6
cpi label_a _ cnt   # 直接将 label_a 处的字节数写入计数器
7
# ... (假装这里有很多代码)
8
label label_a

2 无符号条件判断

xxxxxxxxxx
7
1
# 法一: 判断后跳转
2
label label_1
3
# ... (假装这里有很多代码)
4
if_eq+_i r0 2 label_1
5

6
# 法二: 强制跳转
7
gotoi _ _ label_1

3 有符号条件判断

xxxxxxxxxx
8
1
# 法一: 判断后跳转
2
label label_s
3
# ... (假装这里有很多代码)
4
if_eq+_i+signed r0 2 label_s
5

6
# 法二: 强制跳转
7
const addr r0
8
goto _ _ addr

3.2.2 条件语句代码模板

1 说明

从硬件的角度来说，实际上只有 if not 的语句，当表达式成立时则跳过下一片段，不成立时则执行下一片段。该计算机的指令集中并没有 if 与 switch 等关键字，不过可以通过其他方式实现相同的功能。高级语言的事交给编译器吧，这里不作讨论。

另外，汇编代码中可以定义常量，在编译时将其替换为相应数值即可；定义变量，实际上就是为该变量分配内存，在书写时即把内存地址作为常量赋给变量名。为了便于使用，一般使用高速缓冲寄存器的地址；虽然 RAM 也是可以直接寻址的，但是运算前需要一个时钟脉冲将 RAM 中的数据读取至寄存器中，运算后还需要一个时钟脉冲将结果写回 RAM。

2 if 语句

由跳转语句实现 if 语句的功能：

xxxxxxxxxx
13
1
if_ge+_i a 3 a_ge_3
2
    # if (a < 3)
3
    # do something here
4
    gotoi _ _ end_if_a
5
label a_ge_3
6
if_ge+_i a 10 a_ge_10
7
    # else if (a < 10)
8
    # do something here
9
    gotoi _ _ end_if_a
10
label a_ge_10
11
    # else, i.e. a >= 10
12
    # do something here
13
label end_if_a

上述语句相当于 C 语言中的：

xxxxxxxxxx
7
1
if (a < 3) {
2
    //
3
} else if (a < 10) {
4
    //
5
} else {
6
    //
7
}

3 switch 语句

为了清晰，可以使用下述结构的代码：

xxxxxxxxxx
17
1
if_eq+_i a 0 a_eq_0
2
if_eq+_i a 1 a_eq_1
3
if_eq+_i a 2 a_eq_2
4
gotoi _ _ default
5

6
label a_eq_0
7
    # do something here
8
    gotoi _ _ end_switch
9
label a_eq_1
10
    # do something here
11
    gotoi _ _ end_switch
12
label a_eq_2
13
    # do something here
14
    gotoi _ _ end_switch
15
label default
16
    # do something here
17
label end_switch

上述代码相当于 C 语言中的：

xxxxxxxxxx
14
1
switch (a) {
2
    case 0: {
3
        //
4
    } break;
5
    case 1: {
6
        //
7
    } break;
8
    case 2: {
9
        //
10
    } break;
11
    default: {
12
        //
13
    }
14
}

3.2.3 循环语句代码模板

1 break 与 continue

条件语句要求跳过某一程序片段，而循环语句要求重复执行某一程序片段。硬件上只能实现 while (true) {}，而依靠条件语句跳转出循环。

xxxxxxxxxx
5
1
label a_loop
2
    # do something
3
    if_eq+_i a 0 a_loop
4
    if_eq+_i a 1 end_a_loop
5
label end_a_loop

上述代码相当于 C 语言中的：

xxxxxxxxxx
5
1
while (true) {
2
    // do something
3
    if (a == 0) continue;
4
    if (a == 1) break;
5
}

2 while 循环

xxxxxxxxxx
9
1
label while_loop
2
    if_ne+_i a 1 end_while_loop     # 注意是 if_ne、end_while_loop
3
    # do something
4
label end_while_loop
5

6
label do_while_loop
7
    # do something
8
    if_eq+_i a 1 do_while_loop      # 注意是 if_eq、do_while_loop
9
label end_do_while_loop

上述代码相当于 C 语言中的：

xxxxxxxxxx
7
1
while (a == 1) {
2
    //
3
}
4

5
do {
6
    //
7
} while (a == 1);

3 for 循环

xxxxxxxxxx
9
1
const n 5
2
const i r0
3
cp+i_ 0 _ i
4
label for_loop
5
    if_eq+_i i n end_for_loop
6
    # do something here
7
    add+_i i 1 i
8
    gotoi _ _ for_loop
9
label end_for_loop

上述代码相当于 C 语言中的：

xxxxxxxxxx
4
1
int n = 5;
2
for (int i = 0; i < n; ++i) {
3
    //
4
}

3.3 函数实现与代码实例

3.3.1 函数调用与栈结构

1 函数的功能介绍

1.1 函数的预期功能

所谓函数，就是为了重复利用某段代码，以简化编程流程。与之前的循环语句不同，函数要求在程序中的任意一个地方都可以调用（call）这段代码，并且在调用结束后可以从函数结尾跳转回到（return）程序中原来的位置。

1.2 函数的具体做法

具体来说，可以将函数调用点处的地址存储起来，当函数调用结束后，再将其写入程序计数器中。但是函数的调用存在递归与嵌套的问题，用普通的寄存器无法实现地址的自动存储与取出。先调用的函数后返回，最后调用的函数最先返回，而栈的工作模式刚好满足这样的需求。

2 函数的实现思路

2.1 总体思路

为了实现函数的功能，需要完成两件事：

1. 函数的调用（call）

   1. 将程序计数器的值和指令长度相加；

   2. 将上述值压入栈顶；

   3. 令程序计数器跳转到函数入口处。

2. 函数的返回（return）

   1. 从栈顶弹出地址值；

   2. 将上述值写入程序计数器中。

注意为了实现函数的返回，应当返回调用函数的下一条指令，否则将陷入死循环中。

2.2 栈的实现

思路一：直接使用随机存储器，通过程序在软件上实现栈；

思路二：从硬件上实现栈，程序直接调用该功能（指令）即可。

3 函数的代码模板

3.1 纯软件思路

我们可以通过 RAM 从程序上实现栈，从而实现函数的功能：

xxxxxxxxxx
24
1
const addr r0
2
const temp r1
3
# 初始状态默认为零
4

5
# begin main()
6
    # 调用函数
7
    add+_i cnt 8 temp
8
    gotoi _ _ function_1
9
    
10
    gotoi _ _ end_main
11
# end main()
12

13
# 函数定义
14
label function_1
15
write+ram0 temp addr 0      # 将 temp 压入栈
16
add+_i addr 1 addr          # 压栈后地址自增
17
# begin function_1()
18
    # do something here     # 函数主体
19
# end function_1()
20
sub+_i addr 1 addr          # 弹栈前地址自减
21
read+ram0 temp addr 0       # 弹出栈至 temp
22
goto _ _ temp               # 注意不是 gotoi
23

24
label end_main

3.2 软硬件结合

在 1.3.4 压栈与弹栈中，我们在硬件上实现了栈结构；在 4 压栈与弹栈中，我们将两个栈结构添加到了计算机硬件中。由此，我们可以直接利用栈结构更加便捷地实现函数，而无需花一个字节存储地址、手动指定栈的压入与弹出：

xxxxxxxxxx
20
1
const temp r0
2

3
# begin main()
4
    # 调用函数
5
    add+_i cnt 8 temp
6
    gotoi _ _ function_1
7
    
8
    gotoi _ _ end_main
9
# end main()
10

11
# 函数定义
12
label function_1
13
stkfun push temp _          # 将 temp 压入栈
14
# begin function_1()
15
    # do something here     # 函数主体
16
# end function_1()
17
stkfun pop _ temp           # 弹出栈至 temp
18
goto _ _ temp               # 跳转至程序调用处
19

20
label end_main

3.3 纯硬件思路

在 3.2 的基础上，我们可以在硬件中直接实现 2.1 中函数调用的三个步骤和函数返回的两个步骤。这并不困难，不过需要增加电路和指令，这里略去。

3.3.2 传入参数与返回值

1 函数传参的介绍

在 C 语言中，函数传参有三种方式：

1.1 值传递

值传递的方式，将实际参数的值拷贝至形式参数，函数在执行过程中使用形式参数，即使修改了形式参数，实际参数的值夜不会发生变化。

1.2 地址传递

地址传递的方式，将实际参数的存储地址传给形式参数，尽管函数在执行过程中，修改形式参数不会改变实际参数的存储地址，但是可以直接对存储地址上的数据进行操作，从而改变实际参数的值。

1.3 引用传递

引用传递的方式，直接使用实际参数进行运算，在函数内修改参数，也会直接影响到实际参数的值。

2 函数传参的实现

2.1 引用传递

最直接的方式是使用引用传递，即将要传递的参数固定放在某个寄存器中，函数在调用时直接使用该寄存器的值，而不进行任何其他的处理。不过仍要注意，函数调用过程中可能需要新的内存，需要确保函数不会改变无关的有用信息，因此一种处理方式是将函数可能改变的寄存器中的值，都预先拷贝到 RAM 中，或者压入栈中，待函数结束后，再从 RAM 或栈中取出数据。

2.2 值传递

值传递则是将函数可能改变的所有寄存器中的值（包括传入的参数）都预先压入栈中，于是虽然使用的形式参数的地址与原先实际参数的地址相同，但由于执行结束后将从栈中取出数据，覆盖原地址中的值，因此最终不会改变实际参数的值。

2.3 示例代码

这里以引用传递为例，实现两个数字的交换：

xxxxxxxxxx
27
1
const A r0
2
const B r1
3
const temp r2
4

5
# begin main()
6
    cp in _ A           # 输入 A
7
    cp in _ B           # 输入 B
8
    
9
    add+_i cnt 8 temp   # 预处理, 以实现程序的返回
10
    gotoi _ _ swap      # 调用函数, 交换 A 和 B
11
    
12
    gotoi _ _ end_main  # 结束主函数
13
# end main()
14

15
label swap
16
stkfun push temp _  # 这两行代码用一行就够了,
17
stkpar push temp _  # 只是作为例子体现不同的思路.
18
# begin swap(A, B)
19
    cp A _ temp
20
    cp B _ A
21
    cp temp _ B
22
# end swap(A, B)
23
stkpar pop _ temp
24
stkfun pop _ temp
25
goto _ _ temp
26

27
label end_main

3 函数返回值实现

欲实现函数的返回值，只需要预先指定存储返回值的寄存器，并在函数结束前将需要返回的数据存入该寄存器即可。与传入的参数不同，函数的返回值不需要使用栈的结构。返回值使用固定的寄存器，因此只是暂时的，如果需要返回值，则可以将其拷贝到另一寄存器中。即高级语言中 max(a, b) 和 c = max(a, b) 的区别。

由于直接在硬件的层面操作，函数的返回值可以直接设置为多个，也可以返回数组的地址，只需要预先指定相应的寄存器即可。

3.3.3 汇编语言代码实例

1 部分游戏关卡

1.1 汉诺塔

xxxxxxxxxx
88
1
const disk_nr r0
2
const source r1
3
const dest r2
4
const spare r3
5
const temp r4
6
const switch 5
7
# not r5, though r5 = 5.
8
const delta 8
9

10
# begin main()
11
    # scan input
12
    cp in _ disk_nr
13
    cp in _ source
14
    cp in _ dest
15
    cp in _ spare
16
    
17
    # call function
18
    add+_i cnt delta temp
19
    gotoi _ _ fun_move
20
    
21
    # return
22
    gotoi _ _ end
23
# end main()
24

25
label fun_move
26
stkfun push temp _
27
# begin fun_move(, , , )
28
    if_ne+_i disk_nr 0 exe_subtasks
29
    # if (disk_nr == 0)
30
        # move disk to destination
31
        cp source _ out
32
        cp+i_ switch _ out
33
        cp dest _ out
34
        cp+i_ switch _ out
35
        gotoi _ _ end_move
36
    label exe_subtasks
37
    # else if (disk_nr != 0)
38
        # subtask 1
39
        # 1.1 push params (save)
40
        stkpar push disk_nr _
41
        stkpar push source _
42
        stkpar push dest _
43
        stkpar push spare _
44
        # 1.2 recursive call
45
        sub+_i disk_nr 1 disk_nr
46
        cp spare _ temp
47
        cp dest _ spare
48
        cp temp _ dest
49
        add+_i cnt delta temp
50
        gotoi _ _ fun_move
51
        # 1.3 pop params (read)
52
        stkpar pop _ spare
53
        stkpar pop _ dest
54
        stkpar pop _ source
55
        stkpar pop _ disk_nr
56
        
57
        # subtask 2
58
        # move disk to destination
59
        cp source _ out
60
        cp+i_ switch _ out
61
        cp dest _ out
62
        cp+i_ switch _ out
63
        
64
        # subtask 3
65
        # 3.1 push params (save)
66
        stkpar push disk_nr _
67
        stkpar push source _
68
        stkpar push dest _
69
        stkpar push spare _
70
        # 3.2 recursive call
71
        sub+_i disk_nr 1 disk_nr
72
        cp spare _ temp
73
        cp source _ spare
74
        cp temp _ source
75
        add+_i cnt delta temp
76
        gotoi _ _ fun_move
77
        # 3.3 pop params (read)
78
        stkpar pop _ spare
79
        stkpar pop _ dest
80
        stkpar pop _ source
81
        stkpar pop _ disk_nr
82
    label end_move
83
    # gotoi address saved in temp
84
    stkfun pop _ temp
85
    goto _ _ temp
86
# end fun_move(, , , )
87

88
label end

1.2 新品上市

xxxxxxxxxx
48
1
const left 0
2
const move 1
3
const right 2
4
const skip 3
5
const interact 4
6
const laser 5
7

8
const conveyor 92
9
const obj r0
10
const num r1
11
const temp r2
12
const i r3
13

14
cp+i_ right _ out
15
cp+i_ move _ out
16
cp+i_ right _ out
17

18
label move4
19
    cp+i_ move _ out
20
    add+_i temp 1 temp
21
    if_lt+_i temp 4 move4
22

23
cp+i_ right _ out
24
cp+i_ move _ out
25
cp+i_ left _ out
26
cp+i_ move _ out
27

28
label input_fruit
29
    cp+i_ skip _ out
30
    cp in _ obj
31
    if_eq+_i obj conveyor input_fruit
32
    
33
    cp+i_ 0 _ i
34
    label check_fruit
35
        if_eq i num end_check_fruit
36
        read+ram0 temp i 0
37
        if_ne obj temp check_fruit
38
        
39
        cp+i_ right _ out
40
        cp+i_ interact _ out
41
        cp+i_ left _ out
42
        gotoi _ _ input_fruit
43
    label end_check_fruit
44
    
45
    write+ram0 obj num 0
46
    add+_i num 1 num
47
    gotoi _ _ input_fruit
48
label end_input_fruit

1.3 水世界

xxxxxxxxxx
50
1
const width 16
2
const maxH 10
3
const V r0
4
const i r1
5
const j r2
6
const temp1 r3
7
const temp2 r4
8
const side r5
9

10
label read_all
11
    cp in _ temp1
12
    write+ram0 temp1 i 0
13
    add+_i i 1 i
14
    if_ne+_i i width read_all
15
label end_read_all
16

17
cp+i_ 0 _ i
18
label for_i # vertical
19
    cp+i_ 0 _ j
20
    cp+i_ 0 _ side
21
    label for_j # horizontal
22
        if_ne+_i side 0 left_side
23
        # if parity is even
24
            read+ram0 temp1 j 0
25
            if_lt temp1 i end_if_p
26
            # else it's not empty
27
            cp+i_ 1 _ side
28
            cp j _ temp1
29
            gotoi _ _ end_if_p
30
        label left_side
31
        # if parity is odd
32
            read+ram0 temp2 j 0
33
            if_lt temp2 i end_if_p
34
            sub j temp1 temp2
35
            sub+_i temp2 1 temp2
36
            add V temp2 V
37
            cp j _ temp1
38
        label end_if_p
39
        
40
        add+_i j 1 j
41
        if_gt+_i j width end_for_j
42
        gotoi _ _ for_j
43
    label end_for_j
44
    
45
    add+_i i 1 i
46
    if_gt+_i i maxH end_for_i
47
    gotoi _ _ for_i
48
label end_for_i
49

50
cp V _ out

2 通用代码

2.1 随机数

xxxxxxxxxx
15
1
# 生成随机数
2
const seed r0
3
const temp1 r1
4
const temp2 r2
5

6
cp in _ seed
7
label dance
8
shr+_i seed 1 temp1
9
xor seed temp1 temp1
10
shl+_i temp1 1 temp2
11
xor temp1 temp2 temp2
12
shr+_i temp2 2 seed
13
xor temp2 seed seed
14
and+_i seed 0b11 out
15
gotoi _ _ dance

2.2 排序

xxxxxxxxxx
62
1
const num r0
2
const i r1
3
const j r2
4
# inum = num
5
const jnum r3
6
const temp1 r4
7
const temp2 r5
8
# In order to compare, we have to
9
# define both temp1 and temp2.
10

11
# Code below can scan 256 bytes
12
# at most, until input is 0,
13
# which misunderstands the question.
14
# label scan_all
15
#   cp in _ temp1
16
#   if_eq+_i temp1 0 end_scan_all
17
#   write+ram0 temp1 num 0
18
#   add+_i num 1 num
19
#   gotoi _ _ scan_all
20
# label end_scan_all
21

22
cp+i_ 15 _ num
23
label scan_all
24
    write+ram0 in i 0
25
    add+_i i 1 i
26
    if_eq i num end_scan_all
27
    gotoi _ _ scan_all
28
label end_scan_all
29

30
cp+i_ 0 _ i
31
label for_i
32
# same as for (int i=1; i<n; ++i)
33
    add+_i i 1 i
34
    if_ge i num end_for_i
35
    
36
    cp+i_ 0 _ j
37
    sub num i jnum
38
    label for_j
39
    # for (int j=0; j<n-i; ++j)
40
    if_ge j jnum for_i
41
    # same as break and gotoi
42
        read+ram0 temp1 j 0
43
        add+_i j 1 j
44
        read+ram0 temp2 j 0
45
        if_le temp1 temp2 for_j
46
        # if (a[j] > a[j+1])
47
            write+ram0 temp1 j 0
48
            sub+_i j 1 j
49
            write+ram0 temp2 j 0
50
            add+_i j 1 j
51
        gotoi _ _ for_j
52
    # Continue for_i from for_j, so
53
    # it's needless to write it here.
54
label end_for_i
55

56
cp+i_ 0 _ i
57
label print_all
58
    read+ram0 out i 0
59
    add+_i i 1 i
60
    if_eq i num end_print_all
61
    gotoi _ _ print_all
62
label end_print_all

2.3 首字母大写

xxxxxxxxxx
19
1
const isCapital r1
2
const letter r2
3
const delta 32
4
const space 32
5
cp+i_ 1 _ isCapital
6

7
label capitalize
8
    if_eq+_i isCapital 0 notCapital
9
        sub+_i in delta out
10
        cp+i_ 0 _ isCapital
11
    gotoi _ _ capitalize
12
    label notCapital
13
        cp in _ letter
14
        if_ne+_i letter space send
15
            cp+i_ 1 _ isCapital
16
        label send
17
        cp letter _ out
18
    gotoi _ _ capitalize
19
# end_capitalize

3 其他代码

3.1 ASCII 常量

xxxxxxxxxx
128
1
const ch_nul = 0
2
const ch_soh = 1
3
const ch_stx = 2
4
const ch_etx = 3
5
const ch_eot = 4
6
const ch_enq = 5
7
const ch_ack = 6
8
const ch_bel = 7
9
const ch_bs = 8
10
const ch_tab = 9
11
const ch_lf = 10
12
const ch_vt = 11
13
const ch_ff = 12
14
const ch_ck = 13
15
const ch_so = 14
16
const ch_si = 15
17
const ch_dle = 16
18
const ch_dc1 = 17
19
const ch_dc2 = 18
20
const ch_dc3 = 19
21
const ch_dc4 = 20
22
const ch_nak = 21
23
const ch_syn = 22
24
const ch_etb = 23
25
const ch_can = 24
26
const ch_em = 25
27
const ch_sub = 26
28
const ch_esc 27
29
const ch_fs = 28
30
const ch_gs = 29
31
const ch_es = 30
32
const ch_us = 31
33
const ch_space = 32
34
const ch_excla = 33
35
const ch_dquote = 34
36
const ch_hash = 35
37
const ch_dollar = 36
38
const ch_percent = 37
39
const ch_and = 38
40
const ch_squote = 39
41
const ch_lpqty = 40
42
const ch_rpqty = 41
43
const ch_times = 42
44
const ch_plus = 43
45
const ch_comma = 44
46
const ch_minus = 45
47
const ch_dot = 46
48
const ch_slash = 47
49
const ch_0 = 48
50
const ch_1 = 49
51
const ch_2 = 50
52
const ch_3 = 51
53
const ch_4 = 52
54
const ch_5 = 53
55
const ch_6 = 54
56
const ch_7 = 55
57
const ch_8 = 56
58
const ch_9 = 57
59
const ch_colon = 58
60
const ch_semic = 59
61
const ch_lt = 60
62
const ch_eq = 61
63
const ch_gt = 62
64
const ch_quest = 63
65
const ch_at = 64
66
const ch_A = 65
67
const ch_B = 66
68
const ch_C = 67
69
const ch_D = 68
70
const ch_E = 69
71
const ch_F = 70
72
const ch_G = 71
73
const ch_H = 72
74
const ch_I = 73
75
const ch_J = 74
76
const ch_K = 75
77
const ch_L = 76
78
const ch_M = 77
79
const ch_N = 78
80
const ch_O = 79
81
const ch_P = 80
82
const ch_Q = 81
83
const ch_R = 82
84
const ch_S = 83
85
const ch_T = 84
86
const ch_U = 85
87
const ch_V = 86
88
const ch_W = 87
89
const ch_X = 88
90
const ch_Y = 89
91
const ch_Z = 90
92
const ch_lbqty = 91
93
const ch_bslash = 92
94
const ch_rbqty = 93
95
const ch_xor = 94
96
const ch__ = 95
97
const ch_grave = 96
98
const ch_a = 97
99
const ch_b = 98
100
const ch_c = 99
101
const ch_d = 100
102
const ch_e = 101
103
const ch_f = 102
104
const ch_g = 103
105
const ch_h = 104
106
const ch_i = 105
107
const ch_j = 106
108
const ch_k = 107
109
const ch_l = 108
110
const ch_m = 109
111
const ch_n = 110
112
const ch_o = 111
113
const ch_p = 112
114
const ch_q = 113
115
const ch_r = 114
116
const ch_s = 115
117
const ch_t = 116
118
const ch_u = 117
119
const ch_v = 118
120
const ch_w = 119
121
const ch_x = 120
122
const ch_y = 121
123
const ch_z = 122
124
const ch_lBqty = 123
125
const ch_vqty = 124
126
const ch_rBqty = 125
127
const ch_sim = 126
128
const ch_delta = 127