自制虚拟机

本文根据icemanind的《How to Create Your Own Virtual Machine》系列文章编译，并进行了大量改造（已征得作者同意）。

原文发表于codeproject.com网站，链接地址如下：

第一部分 · 第二部分

源代码：点击下载

英文教程：点击下载

序言

By Conmajia

各位，你正在阅读的这个系列的文章将从零开始，带你一步一步设计并实现一个完整可运行的虚拟机（Virtual Machine）。我们将要使用C#语言，基于Microsoft .NET Framework 2.0运行库来完成整个虚拟机的制作（出于兼容性考虑，也是为了将主要精力集中在设计上）。因此，你需要具备最基本的.NET程序开发知识。也就是说，至少你应该会使用Visual Studio 2005（或者更高版本），并且能成功运行自己的「Hello World」程序。

在开始设计前，让我们先来了解一下虚拟机的相关知识。

虚拟机是一种模拟硬件环境的中间件（Middleware），是一种高度隔离的软件容器，它可以运行自己的操作系统和应用程序，就好像它是一台物理计算机一样。虚拟机的行为完全类似于一台物理计算机，它包含自己的虚拟（即基于软件实现的）CPU，有些甚至扩展了RAM、硬盘和网络接口卡（NIC）等虚拟硬件。

操作系统无法分辨虚拟机与物理机之间的差异，应用程序和网络中的其他计算机也无法分辨。即使是虚拟机本身也认为自己是一台「真正的」计算机。不过，虚拟机完全由虚拟机软件组成，不含任何硬件组件。因此，虚拟机具备物理硬件所没有的很多独特优势。

虚拟机的优势

一般而言，虚拟机具备以下四个关键特征：

• 兼容性：虚拟机与所有标准的 x86 计算机都兼容
• 隔离：虚拟机相互隔离，就像在物理上是分开的一样
• 封装：虚拟机将整个计算环境封装起来
• 独立于硬件：虚拟机独立于底层硬件运行

好了，下面就开始设计我们自己的虚拟机。

设计虚拟机

我们要为这个虚拟机绘制一个蓝图。我们给虚拟机起名为：B32，代号SunnyApril（SA for short）。为了简化设计，SA被设计成一个16位的机器（这意味着她的CPU位宽是16-bit的）。这样一来，SA能够支持的地址空间就是0000H-FFFFH。现在我们为SA加入5个寄存器（Register）。寄存器是计算机硬件的一个重要概念和组件。寄存器是具有有限存贮容量（通常是1、2字节）的高速存储部件，用来暂存指令、数据或者地址。几乎所有的CPU和虚拟机中都包含有内建的寄存器。简单来说，寄存器就是「CPU内部的内存」。

为了简单，我们只设计了5个寄存器，分别是A、B、D、X和Y。A、B寄存器是8位寄存器，可以保存0-FFH的无符号数或是80H-7FH的有符号数。X、Y和D寄存器都是16位的，可以保存0-FFFFH的无符号数或是8000H-7FFFH的有符号数。同样是为了设计简便，目前我们只考虑无符号数的情况，有符号数将在后面研究浮点数的时候一起进行。

D寄存器是一个特殊的16位寄存器。它的值是由A、B寄存器的值合并而成，A保存了D的高8位值，B保存了低8位值。例如A寄存器值为3CH，B寄存器值为10H，则D寄存器值为3C10H。反之，如果修改D寄存器值为07C0H，则A寄存器值变为07H，B寄存器值变为C0H。

下面的图形象地说明了各寄存器的规格和之间的关系。

为了让我们的虚拟机能在第一时间「反馈」运行结果，我们从64KB的内存空间中留出4000字节的空间（A000H-AFA0H）作「显示器」缓存。我们模仿DOS下的汇编语言，用其中2000字节用于保存显示字符（这样可以得到80x25的字符屏幕），2000字节用于保存每个字符的样式。每个样式字节低3位分别表示前景色的红、绿、蓝颜色值，第4位表示明暗度，5-7位同样，用于表示背景颜色。样式字节的最高位本来是表示是否闪烁字符，但在我们的设计中不需要这个功能，所以直接忽略。

接下来的工作就是设计能让虚拟机运行起来的指令集（即字节码）了。指令集和我们自制的「汇编语言」一起设计，简便起见，先设计4个指令，如图所示。

以LDA指令（字节码01H）为例，该指令将操作数（#41H）存入A寄存器，即「Load A」。由于操作数寻址方式太多，这里简单地用「#」符号起头，表示「立即数」（模仿51单片机的汇编语言）。以「H」结尾的数字表示为16进制，类似的有「O」（八进制）、「B」（二进制）和「D」（十进制，可以省略）。

END指令（字节码04H）表示程序结束。同时它后面的「标签」表示程序的起始标签，用于标注程序运行的开始位置。标签是使用「:」半角冒号结尾的单独成行的字母开头的字符串，如START标签就这样书写：

1. START:  

接下来是设计编译后的字节码文件格式。大部分的二进制文件格式都是以一串「魔法数字」字符串开头的。例如，DOS/Windows文件用「MZ」开头，Java二进制文件用4字节的数字3405691582开始，用16进制表示就是「CAFEBABE」（咖啡宝贝）。我们的SunnyApril就使用「CONMAJIA」作为魔数。魔数之后是文件体偏移量，表示文件体（即程序字节码）在文件中的起始位置。接着是程序长度，即文件体长度。执行地址表示字节码执行起始地址，固定为0。（后续可能会改变）偏移段用于保存额外的数据或者中断向量表等，其长度为「偏移量-13」字节。文件头后就是文件体，保存了程序编译后的全部字节码。文件结构参见下图。

汇编器

现在我们可以开始动手设计汇编器了。这个汇编器将能够把我们写好的汇编源程序编译后写入到可以供虚拟机运行的二进制字节码文件中。汇编文件格式如下： 

1. [标签:]  
2. <指令><空白><操作数>[空白]<换行>  

其中，方括号[]中的内容是可选的。

注：以下内容和源代码经过较大幅度的改造和优化，和原文差异较大，注意区别。

这就是我们的汇编源程序：

1. START:  
2. LDA #65  
3. LDX #A000H  
4. STA X  
5. END START  

这个程序的功能就是简单地把字符'A'输出到屏幕的左上角。第一行代码定义了START标签。第二行将立即数65（即ASCII代码'A'）存入A寄存器。第三行将立即数A000H（即显示缓存的起始地址，参见《设计》一节）存入X寄存器。第四行代码将A寄存器中的值（65）存入X寄存器中的数值（A000H）代表的内存地址。最后用END结束程序。

下面我们运行Visual Studio，新建一个「Windows窗口应用程序」项目，选择.NET Framework版本为2.0，仿照下面的截图设计窗体。

其中，textBox1.Readonly属性设置为true，numericUpDown1.Hexadecimal属性设置为true。

首先在窗体类中建立如下的变量。

1. Dictionary<string, UInt16> labelDict;  
2. UInt16 binaryLength;  
3. UInt16 executionAddress;  

定义一个寄存器枚举。

1. enum Registers  
2.  {  
3.      Unknown = 0,  
4.      A = 4,  
5.      B = 2,  
6.      D = 1,  
7.      X = 16,  
8.      Y = 8  
9.  }  

在窗体的构造函数中初始化变量和控件。

1. public Form1()  
2.  {  
3.      InitializeComponent();  
4.      labelDict = new Dictionary<string, ushort>();  
5.      binaryLength = 0;  
6.      executionAddress = 0;  
7.      numericUpDown1.Value = 0x200;  
8.  }  

button1的功能是打开「文件浏览」对话框选择需要汇编的源文件。双击button1，在生成的Click事件中输入以下代码：

1. OpenFileDialog ofd = new OpenFileDialog();  
2.  ofd.Filter = "SunnyApril Assembly Files(*.asm)|*.asm";  
3.  ofd.DefaultExt = "asm";  
4.  ofd.FileName = string.Empty;  
5.  if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)  
6.      textBox1.Text = ofd.FileName;  
7.  else  
8.      textBox1.Clear();  

button2功能是执行汇编，并生成二进制字节码文件，主要代码如下：

1. if (textBox1.Text == string.Empty)  
2.      return;  
3.    
4.  labelDict.Clear();  
5.  binaryLength = (UInt16)numericUpDown1.Value;  
6.    
7.  FileInfo fi = new FileInfo(textBox1.Text);  
8.    
9.  BinaryWriter output;  
10.  FileStream fs = new FileStream(  
11.      Path.Combine(  
12.      fi.DirectoryName,  
13.      fi.Name + ".sab"),  
14.      FileMode.Create  
15.      );  
16.  output = new BinaryWriter(fs);  
17.    
18.  // magic word  
19.  output.Write('C');  
20.  output.Write('O');  
21.  output.Write('N');  
22.  output.Write('M');  
23.  output.Write('A');  
24.  output.Write('J');  
25.  output.Write('I');  
26.  output.Write('A');  
27.    
28.  // org  
29.  output.Write((UInt16)numericUpDown1.Value);  
30.    
31.  // scan to ORG and start writing byte-code  
32.  output.Seek((int)numericUpDown1.Value, SeekOrigin.Begin);  
33.    
34.  // parse source code line-by-line  
35.  TextReader input = File.OpenText(textBox1.Text);  
36.  string line;  
37.  while ((line = input.ReadLine()) != null)  
38.  {  
39.      parse(line.ToUpper(), output);  
40.      dealedSize += line.Length;  
41.      Invoker.Set(progressBar1, "Value", (int)((float)dealedSize / (float)totalSize * 100));  
42.  }  
43.  input.Close();  
44.    
45.  // binary length & execution address (7 magic-word, 2 org before)  
46.  output.Seek(10, SeekOrigin.Begin);  
47.  output.Write(binaryLength);  
48.  output.Write(executionAddress);  
49.  output.Close();  
50.  fs.Close();  
51.    
52.  MessageBox.Show("Done!");  

在这个方法中，通过一个while逐行解析源代码（原作者是全文解析），解析方法如下：

1. private void parse(string line, BinaryWriter output)  
2.  {  
3.      // eat white spaces and comments  
4.      line = cleanLine(line);  
5.      if (line.EndsWith(":"))  
6.          // label  
7.          labelDict.Add(line.TrimEnd(new char[] { ':' }), binaryLength);  
8.      else  
9.      {  
10.          // code  
11.          Match m = Regex.Match(line, @"(\w+)\s(.+)");  
12.          string opcode = m.Groups[1].Value;  
13.          string operand = m.Groups[2].Value;  
14.    
15.          switch (opcode)  
16.          {  
17.              case "LDA":  
18.                  output.Write((byte)0x01);  
19.                  output.Write(getByteValue(operand));  
20.                  binaryLength += 2;  
21.                  break;  
22.              case "LDX":  
23.                  output.Write((byte)0x02);  
24.                  output.Write(getWordValue(operand));  
25.                  binaryLength += 3;  
26.                  break;  
27.              case "STA":  
28.                  output.Write((byte)0x03);  
29.                  // NOTE: No error handling.  
30.                  Registers r = (Registers)Enum.Parse(typeof(Registers), operand);  
31.                  output.Write((byte)r);  
32.                  binaryLength += 2;  
33.                  break;  
34.              case "END":  
35.                  output.Write((byte)0x04);  
36.                  if (labelDict.ContainsKey(operand))  
37.                  {  
38.                      output.Write(labelDict[operand]);  
39.                      binaryLength += 2;  
40.                  }  
41.                  binaryLength += 1;  
42.                  break;  
43.              default:  
44.                  break;  
45.          }  
46.      }  
47.  }  

其中用到了读取字节（byte）操作数的内部方法，如下所示。稍作改进可以很方便地支持多种数制。读取字（Word）操作数的方法与此类似，不再另作说明。

1. private byte getByteValue(string operand)  
2.  {  
3.      byte ret = 0;  
4.      if (operand.StartsWith("#"))  
5.      {  
6.          operand = operand.Remove(0, 1);  
7.          char last = operand[operand.Length - 1];  
8.          if (char.IsLetter(last))  
9.              switch (last)  
10.              {  
11.                  case 'H':  
12.                      // hex  
13.                      ret = Convert.ToByte(operand.Remove(operand.Length - 1, 1), 16);  
14.                      break;  
15.                  case 'O':  
16.                      // oct  
17.                      ret = Convert.ToByte(operand.Remove(operand.Length - 1, 1), 8);  
18.                      break;  
19.                  case 'B':  
20.                      // bin  
21.                      ret = Convert.ToByte(operand.Remove(operand.Length - 1, 1), 2);  
22.                      break;  
23.                  case 'D':  
24.                      // dec  
25.                      ret = Convert.ToByte(operand.Remove(operand.Length - 1, 1), 10);  
26.                      break;  
27.              }  
28.          else  
29.              ret = byte.Parse(operand);  
30.      }  
31.    
32.      return ret;  
33.  }  

运行汇编器，对前面保存的demo1.asm文件进行汇编，得到demo1.sab二进制字节码文件，该文件内容如下：

可以见到，汇编器忠实地完成了我们交代的任务，正确计算了文件大小，在0200H位置处开始，汇编出的字节码为「01 00 02 00 00 03 10 04 00 02」，下面我们对照源程序进行检验。为了便于观察，再写一遍源程序。

1. START:  
2. LDA #65  
3. LDX #A000H  
4. STA X  
5. END START  

第一行为START标签，将地址0200H存入缓存（在文件中没有体现）。

第二行LDA指令，存入字节码01H，然后存入单字节操作数（A寄存器是8位寄存器）65，即41H。

第三行LDX指令，存入字节码02H，然后存入双字节操作数（X寄存器是16位寄存器）A000H，由于计算机采用小端模式（低位在前），所以在文件中是以「00 A0」的形式存储的。

第四行STA指令，存入字节码03H，然后存入Registers.X枚举值（16，即01H）。

第五行END指令，存入字节码04H，然后存入START标签地址0200H（2字节，仍以小端模式存储）。

根据以上分析，我们制作的汇编器完全符合设计。

下一步，我们将开始设计虚拟机，敬请期待。

欢迎各种建议意见。

（第一部分 完）