从虚拟机架构到编译器实现导引【一本书的长度】

栏目: 服务器 · 发布时间: 6年前

内容简介：在说些什么实现的东西之前,笔者仍然想话唠唠叨下虚拟机这个话题,一是给一些在这方面不甚熟悉的读者简单介绍下虚拟机的作用和包治百病的功效,二来是题头好好吹一吹牛,有助于提升笔者在读者心中的逼格,这样在文中犯错的时候,不至于一下就让自己高大上的形象瞬间崩塌。是的，当前虚拟化技术已经在计算机及互联网中烈火燎原了，从服务器到个人PC上直至手机甚至手表上，几乎都离不开它的身影，尽管当前说起虚拟机，更多的人想到的是Java是运行在JVM上的，而JVM是个虚拟机，或者大家非常熟悉的虚拟机软件VMWare或者是Virtua

在说些什么实现的东西之前,笔者仍然想话唠唠叨下虚拟机这个话题,一是给一些在这方面不甚熟悉的读者简单介绍下虚拟机的作用和包治百病的功效,二来是题头好好吹一吹牛,有助于提升笔者在读者心中的逼格,这样在文中犯错的时候,不至于一下就让自己高大上的形象瞬间崩塌。

是的，当前虚拟化技术已经在计算机及互联网中烈火燎原了，从服务器到个人PC上直至手机甚至手表上，几乎都离不开它的身影，尽管当前说起虚拟机，更多的人想到的是 Java 是运行在JVM上的，而JVM是个虚拟机，或者大家非常熟悉的虚拟机软件VMWare或者是Virtual

Box，KVM等大牌虚拟机软件。但实际上虚拟化技术早而有之甚至不那么容易界定明显，例如，我们在PC上想玩红白机游戏，那么FC模拟器就是个虚拟机，我们想在PC上做做电路实验，试试我们在89C51上编写的跑马灯好不好使，proteus也是虚拟机,甚至于做做虚拟仪器的业内标杆软件Labview,这个无需解释估计是最直观的虚拟机了,大多数虚拟机本质上是执行在宿主的一款程序,对宿主机CPU没办法直接执行的指令字节流或别的一些什么东西进行解释执行,最终达到某种功能或目的的一种程序,那么按照这种推论,浏览器里的JavaScript,Lua脚本语言运行环境,或者是 Python 算不算虚拟机呢,实际上大多数人更愿意使用解释器来描述这些语言的执行环境,但是不管怎么说,乍看之下其似乎也完全符合虚拟机的特性,不管是文字解释还是将代码编译为字节流再进行解释本质上并没有多少区别,因此笔者认为将它们归为虚拟机也一点毛病也没有,纠结这些毫无意义.

那么简单来讲虚拟机到底是什么呢,简单来说,假如你只会中文而不会英文,某天一个老外要和你交谈,语言不通怎么办,请翻译啊,那么,这个翻译的作用就像虚拟机.

为什么我们要设计一个虚拟机

相信在文章的开篇就有人跳出来提出这个问题了,为什么要自己做个虚拟机,现在那么多现成的执行体系不好么,为什么要重复造轮子,何况这个轮子还未必有别人的圆,当然笔者写这篇文章的目的也并不是吹嘘自己写的虚拟机有多好,但笔者相信只要你在计算机开发的游戏引擎或二进制安全或图形图像或是人机交互PLC工控…等等等领域之一混的足够久,你就会知道自己拥有自己的一套虚拟机系统所带来的好处和必要性了,笔者相信时间和经验会告诉你做一件事有没有这种必要,而别人说再多话也是别人说的,当然,就像别人设计的虚拟机再好也是别人的,自己设计的虚拟机再挫也是自己的.当你在一套虚拟系统中有所疑惑或者是需要额外的功能实现时,你就知道”就算别人的花儿再漂亮,自己种的终归是自己种的”这句话的深刻含义了.

那么,一套虚拟机系统有什么好处呢?笔者总结了部分功能.

跨平台使用,在这台机器上是这套虚拟机指令集,在另一套计算机上也是同样的虚拟机指令集,一次开发,永久奔放,当然,你必须也保障目标机能够移植你的虚拟机。

执行环境可控，毕竟每一条指令都由虚拟机负责解释执行，这意味着可以对程序执行的每一个流程进行控制，虚拟机作为一个沙盒环境，对权限控制，调试都有诸多好处。尤其是在权限的控制中，可以避免一些恶意程序对原生系统的破坏，当然，这有没有让你有种主宰世界的感觉。
二进制安全，当然目前最让人头疼的是一款软件刚发布又让人给破解了，当然，破解工作必然的涉及到了软件的逆向工程，逆向工程就必然和指令集运行环境有所关联了，当然早期的反逆向技术主要花心思在如何检测调试器上了，然而当开发了一种检测调试器的手段，逆向人员很容易就找得到应对的方法，因此，检测调试器的手段发展到今天基本作为一种备用手段了，虽然说理论上世界上不存在不能被破解的软件，但是当一款软件的破解难度远远大于其本身价值的话，那么这款软件被破解的可能性就变得很低了，那么为什么软件容易被破解呢，很多时候是因为大家都熟悉这套框架这套指令集这套运行原理，用的人多了，资料就多了，资料多了，那程序就没啥隐私了，但是如果自己设计一套全新的指令集和框架结构的虚拟机的话，要破解运行在这个虚拟机上的软件，就意味着攻击者必须熟悉这个指令集和框架的原理，好了，现在问题就变成了当你面对一个运行在全新的架构全新的指令集上的程序时，你有几年的青春可以挥霍了，当前反调试技术并非是让人做到无法破解，而是需要花大于程序本身的价值的精力去破解，正因如此，虚拟机尤其是自己设计的虚拟机成了反逆向分析中的“宠儿”。

当然如果说读者读完这篇文章就能马上撸出一个虚拟机+完整的编译系统,那真是难为笔者了,这也就是为什么题目中笔者加了导引两个字,这是一个庞大的工程,笔者无法在寥寥万余字中将每一个技术细节都说明白,当中涉及的东西太多不仅在书里更要在实现中去体会而不是纸上谈兵(相信我,那些把编译理论吹得稀烂的大多自己也没有写过编译器最多就使用LLVM描了个边,当他们真正从底层去处理词法和语法上的问题基本也是一脸懵,那一刻就会体会到真正要他们解决的玩意书和那套听不懂的装逼理论并不会告诉他们),虽然书不能帮你解决所有问题,但笔者仍然向有兴趣写编译器虚拟机的推荐\<\<编译原理\>\>\<\<游戏脚本高级编程\>\>这两本书,前者有一套完整的编译理论的构架对学习编译优化非常有好处,当然其实很大一部分理论用不到,后者那本书则是结结实实的写了一套完整的虚拟机和编译器,不过也厚的多,足足2本书近千页的内容(当然,还是无法完全提及每一个技术细节:),但非常有参考价值值得一读.最后是笔者的这篇文章了,是的,虽然无法让读者直接写出个编译器和虚拟机,但是至少可以说个大概,2w字的篇幅说长不长说短不短,半个小时就能读完,买不了吃亏买不了上当,可以让你初略地了解下虚拟机和编译器到底是怎么回事.

虚拟机开发前的准备工作

在码农界设计一个虚拟机一直被当做高端大气上档次的事.然而事实上虚拟机的设计并没有什么复杂的内容,乃至于说解释器里的语法和词法分析都比虚拟机复杂的多,当前,假如你想设计一款和VMWare或者Virtual

Box一样的的虚拟机软件,那当我之前的话没说,在本文中,笔者通过设计一款较为简单的虚拟机程序并且在虚拟机完成我们需要的功能.

因此,在开始这个项目之前，我们首先要确立以下目标

我们要虚拟机主要功能是什么，功能的不同，将很大程度改变虚拟机的架构，例如是我们的虚拟机实作为游戏引擎的脚本控制，那么我们的指令设计就应该尽可能的精简稳定并便于优化，这样使用虚拟机设计的游戏引擎才不至少不至于在虚拟机方面卡成PPT让每一个玩家骂娘，而如果是做算法的反逆向保护，那么我们就要好好的藏好我们指令集“真正的”功能，甚至不做优化让破解者绕圈圈，这个时候冗余设计反而有助于保护我们的算法。
我们的虚拟机开发环境是什么，用在什么地方，当然，这包括使用什么语言，什么环境来开发我们的虚拟机都在考虑的范围之内，当然，当前相当一部分有名的虚拟机环境都选择使用 C语言进行开发，这有很多好处，首先目前绝大部分的运行环境都提供C语言的编译器，虚拟机写好后，可以非常方便地在多平台进行移植，再者只要编译器给力，C语言编译出来的指令流相对执行效率优秀，这对容易带来明显性能损失的虚拟机尤为有利，最后，C语言学习较为容易，学习成本不高，能让我们把更多的注意力放在“如何实现”而不是“如何让别人觉得我代码语法糖写的有多牛逼”上。
我们的虚拟机的指令集如何实现，当然这是一个笼统的说法，这还包括如何我们虚拟机如何对内存进行管理，需要哪些寄存器，这些寄存器分别由什么用，指令的数据结构是怎么样的之类多种的问题，不过不用担心，我们有很多现成的指令集可以供我们参考,例如MIPS这种指令集至今仍作为众多CPU粉乐于用虚拟机模拟实现的指令集,这原于这个指令集的精简并容易实现,因此每年的毕设上,总能看到相关的设计论文,相对的x86

ARM指令集就复杂得多,但不用担心,我们可以学习他们部分的实现,管中窥豹可见一斑,即使我们只完成了一部分实现,对于我们的虚拟机而言,大部分的功能也足够实现了.
如何设计调试器方便我们的虚拟机调试,这个是非常重要的一点,假如你设计的虚拟机没有对应的调试方案,那么即使是作为虚拟机作者的你编写的虚拟机程序进行亲自调试,也将会是一场噩梦,因此在你真正动手开发虚拟机之前,你最好想好你的调试器如何架构在你的虚拟机之上.
虚拟机的运行方式及IO,简单来说就是你得想好你的虚拟机如何去解析指令执行,另外虚拟机执行完后也不能光运行啊,算法把结果算出来了总得把结果输出来,这就涉及到了虚拟机和本地代码的数据交互,这些都需要提前考虑好.
虚拟机的异常处理方式,老规矩,除0异常,越界访问,无效指令,内存不足…不管你设计的虚拟机再如何的优秀,如果没有异常处理方式,那就是一句话”怎么死的都不知道”,因此不管你设计哪一种虚拟机,你最好先把算盘打好当出现这些异常的时候,你的虚拟机应该如何应对.

架构一个虚拟机

给虚拟机项目个名字和LOGO

项目开始的第一步,自然没多少难度,不过但凡干大事者,都要先立个名号,虽然说这并不算什么大事,但笔者自认为是一个比较中二病的人,因此,左思右想还是得给这个虚拟机项目取个名字.比如终结者,双子星,地球毁灭者,宇宙收割机之类的,不过好像又过了那个年纪,还是务实一点,当然,本篇文章的事例虚拟机取自笔者早前已经写好的一个虚拟机项目,它被用在游戏引擎,嵌入式系统控制及UI界面当中,名字是早已订好了叫StoryVM,属于StoryEngine(游戏/图像引擎)的一部分

至于为什么叫StoryVM,笔者自己也不是很清楚.就觉得叫着舒服,当然,本篇文章的目的也是告诉大家这个虚拟到底如何实现的,读者们如果有兴趣,不妨也花点时间为自己的虚拟机项目起个霸气的名字和LOGO,万一火了,那么就可以为这个虚拟机名字怎么来的想个故事了.

认识冯诺依曼结构和哈佛架构

在开始部署我们的虚拟机程序之前,我们先来复习一下计算机专业的经典知识点,冯诺依曼的计算机体系结构和哈佛结构,相信计算机系的看官们应该并不陌生毕竟多多少少都有几位是栽在他们手上的

冯诺依曼和哈佛结构主要的不同点是程序和运行数据是否是存储在同一个空间中,实际上两种体系虚拟机都能够实现,毕竟时间有限,因此,笔者无法将两种体系的虚拟机实现都说一遍,出于演示和尽可能偷懒原则,笔者在本文中采用的是哈佛结构体系的虚拟机架构,为什么使用哈佛结构(程序和数据分开存储)呢,其中有以下几点好处

从执行安全性考虑,方便进行越界检查,当指令地址不在指令的存储范围内时,肯定是无效指令越界访问了.
二进制漏洞十有八九都是越界访问或者缺少边界检查的数据修改造成的,程序修改程序造成远程代码执行的事儿咱们也不是第一天见过了,因此,分开存储有利于提高脚本的安全性与可控性.
简单啊,写起来方便啊,偷懒舒服啊,分开存储意味着很多时候你不必再使用多个数据费力寻找数据的真实偏移量了,实际上笔者在虚拟机的实现过程中,将字符串,文本,内存,寄存器空间全部分开存储.

那么,这个虚拟机的数据空间看起来是怎么样的呢:

是的,笔者将虚拟机的各个数据都进行分类存储,一来不仅便于访问,二则方便管理及权限控制,只要设计得当,常量区的只读数据就能得到很好的保护,程序代码区也不会被修改,需要注意的是,笔者仍然将栈空间和堆空间设计在同一空间里,当然这是有一定原因的,这点我会在后面的章节中说出原因.

元数据

那么从现在开始,我们就要开始接触一些编码方面的东西了,当然,为了保证这篇文章尽可能的受众面广,笔者并不打算过于地强调用何种语言来编写这个虚拟机,但笔者编写这个虚拟机使用的是C语言进行开发的,因此在很多的地方,仍然不可避免需要使用C语言中的一些代码对功能的实现进行说明,明显的,本文并不打算写有关C语言怎么写之类的问题,因此如果读者不熟悉C语言的话,笔者仍然建议读者自行查阅相关资料.

在虚拟机开发的第一步,我们先来了解一下元数据

什么是元数据呢,简单来说就是虚拟机能够定义的最小单位,我们以C语言为例,C语言排除结构体和修饰符外,那么能够定义char

short int float double

long….等几种类型,其中,char类型不论在哪种编译器下必定占据一字节,排除位域或编译器额外的实现,char是C语言能够定义的最小数据大小,因此我们称char为元数据类型

而在Basic语言中,定义则简单的多,可以直接使用dim a=3141,或者dim b=”hello

world”来定义类型,在这个时候,类型所需的内存空间不再是一个定数.在这里定义的元数据类型可以是一个整数小数或者是字符串类型.

在很多的情况下,我们把类似于C语言的类型称为强类型,表示类型间无法直接相互转换,而Basic则称为弱类型,不同类型间可以相互转换.

当然,对于那些依靠CPU直接执行的指令,基本不会采用弱类型的数据访问方式,这将导致电路实现过于复杂,但是虚拟机完全可以采用弱类型的方式来编码数据的访问,这主要有以下几个优点.

编写程序时简便的多,这意味着开发虚拟机程序时不用花过多的心思在数据转换上
写起来方便,看起来直观,比如”Hello”+”World”这样的字符串相加运算,顺手
不需要再关注一些例如字符串类型带来的内存管理上的麻烦,这些都由虚拟机适时分配与回收(garbage
collection)

当然,弱类型带来了优点,缺点也不少

显然的,虚拟机的实现要复杂的多,必须考虑资源分配、深浅拷贝、垃圾回收等问题。
必定带来性能损失，尤其是面临深拷贝和垃圾回收。
不论内存管理如何优秀，这种分配回收机制都不可避免引发更多的内存碎片
对一些特殊类型的操作,比如字符串,可能需要额外增加一些关键字来加强对类型功能的使用,比如字符串不可避免需要引入strlen函数统计其长度,或者用[]运算符修改其某个字符.
容易引发语法上的歧义，例如一个字符串类型和一个整数类型相加，如何定义？例如

“数字:”+4294967295的结果应该是字符串’’数字:4294967295”么?,要知道,4294967295在32位类型中和数字-1是一样的,如果”数字:”+4294967295是字符串”数字:4294967295”那”数字”+-1又该是什么,你可以说给类型定义有符号还是无符号的标识啊,那么好,定义一个类型为100,那么这个100是有符号还是无符号的,你可以说加修饰符来修饰啊,那问题又来了,既然要加修饰符,那我还用弱类型做什么,绕个弯子再自找麻烦么.

总结了弱类型的几个好处,但同时我们也发现其糟糕的地方也不少,那我们虚拟机需要设计成支持弱类型的访问么,当然要,弱类型有如此多的好处,不能因为他存在某些缺点就全盘否定,但这也是为什么本章标题笔者起名为元数据而非”都听好了,我们要设计一个弱类型数据访问型的虚拟机”,为了规避弱类型访问的一些缺点,我们需要对虚拟机的数据结构进一步改造,我们可以这样规定,一个元数据(可能是常规寄存器,堆栈里的某一数据)可以是一个整数,小数,或者是字符串或数据流类型,但是,不同的数据类型不能够直接进行运算,需要使用特殊的指令进行操作,这样我们就解决了弱类型带来的歧义的问题.

说完了理论,我们来看看实践,我们先来看看C语言如何定义一个元数据

typedef struct

{

int type;

union

{

char _byte;

char _char;

word _word;

dword _dword;

short _short;

int _int;

uint _uint;

float _float;

string _string;

memory _memory;

};

} VARIABLE;

观察结构体VARIABLE定义,其中type表示该变量的类型,在该虚拟机中,有如下枚举定义

typedef enum

{

VARIABLE_TYPE_INT,

VARIABLE_TYPE_FLOAT,

VARIABLE_TYPE_STRING,

VARIABLE_TYPE_MEMORY,

} VARIABLE_TYPE;

VARIABLE_TYPE_INT,表示这个数据是一个整数类型定义,
VARIABLE_TYPE_FLOAT表示这个数据是一个浮点类型,

VARIABLE_TYPE_STRING表示这是一个字符串类型定义

VARIABLE_TYPE_MEMORY 表示这是一个数据流类型

接下来是一个联合体,数据类型公用一块内存尽可能节省一个元类型占用的内存空间

数据表达方式

如果在高中数学的角度上来说,6和6.00这两个数字并没有什么区别,6.00后面的两个0可以省略,但是在很多的编程语言当中,6和6.00有着本质上的区别,6是一个整数,6.00是一个浮点数,它们在内存中的布局常常天差地别,同时,6/4和6.00/4的结果也截然不同

笔者在本章开头写这个,目的并不是给读者讲解整数和浮点数编码的区别,而是希望提及一点,数据的不同写法所表达出的数据也截然不同,那么StoryVM支持几种数据呢,在上一章节我们已经讲过元数据的组成方式,从结构体定义我们可以看到,支持char

short int uint float string memroy几种类型(word ,dword..本质上是unsigned

short和unsigned

int),但是笔者并不打算让StoryVM关注于如此多的类型,因此,在笔者设计的StoryVM中,仅仅支持int

float string memroy四种类型

读者可能会表示疑问.如果我需要表示一个无符号数,或者只需要表示一字节那怎么办,int类型不是只能表示有符号整数呢

其实按照读者的设计,在方便的时候,数据长度可以宁多不宁少,int类型完全可以用来表示字节类型,无非是使用时自己注意点将它当做字节类型来用时不要超过255就行了,而有符号无符号类型在内存中表示其实并没有什么出入,例如,-1和4294967295在内存中并没有什么区别,而有符号数适用面更为广泛,至于到底显示出来时是有符号或者是无符号,完全可以靠自己把握.

在StoryVM中,如何使用汇编表示一个数据类型呢

显然的 int类型可以直接使用数字来表示,例如

12345,这个是一个合法的int类型,当然,为了方便,还引入了十六进制表达,例如0xffffffff也是一个合法的int类型,当然,需要注意的是StoryVM最大支持32位的整数类型,这也意味着十六进制范围是0\~0xffffffff,最后是字符类型,例如‘A’表示字符A的asc码值,也是一个合法的整数类型,’B’表示字符B的ascii码值…..以此类推

Float类型应该无需笔者多说了,1.0,3.14,6.66都是合法的float类型

String也就是字符串类型和C语言的字符串表示保持一致,”Hello

World”这就是一个合法的字符串类型,用双引号包含,当然,和C语言有些不同的是,字符串类型中仅支持\r\n\t三种类型转义

最后是数据流类型,这个是StoryVM中自定的一种数据类型,理解起来并不复杂,例如

\@0102030405060708090A0B0C0D0F\@这就是一个数据流类型,一个数据流类型使用两个\@包含,当中的文本是一个十六进制表示的数据流,两两为一对为一字节,这也就意味着当中的字符数必须在范围0-F中,并且必定是偶数个.

指令集数据结构

在开始设计具体的指令前,我们先来考虑下虚拟机指令集如何设计,当然,当前的指令集大多以如下的模式设计:

其中,操作码表示这条指令的具体作用,例如x86汇编中的MOV eax,1中的mov就是操作码

紧接在操作码之后的是操作数类型(或者也可以叫参数类型),例如上上面这条汇编指令中一共有2个操作数(参数),分别是eax和数字1,它们分别表示一个寄存器类型和一个立即数类型,最后是操作数了,也就是我们常说的参数.

当然,上述的规则适用于大多数的指令编码格式,对于一些非常常用的指令,甚至会将一些操作数给”集成”到操作码中,例如上述的MOV

eax,1指令中,mov

eax,被直接用E8代替,而操作数1则直接使用一个dword来设置,在这条指令中,只有一个操作码和一个操作数.

如此的设计可以保证编译的程序尽快能的小,但是作为代价,执行对于的指令集的CPU或虚拟机也需要设计更多的实现而变得越来越复杂

设计出x86类似的复杂指令集需要耗费大量的心血,但在我们的虚拟机系统中,我们无需使用如此复杂的指令集设计

笔者斟酌了定长指令和不定长指令的一些特点,设计出如下的一套指令集规范

操作码以1字节进行标识
接着是3字节的操作数类型
依据指令类型最终决定之后跟几个操作数,每个操作数都是一个4字节宽度的类型

这意味着我们的指令设计每个指令至少占4字节宽度,并且最多只能接受3个操作数.

寄存器设计

在CPU设计,寄存器用于数据的暂存,在电路设计中,这不同的寄存器被赋予不同的意义,在笔者的虚拟机架构中,并不需要关注电路设计如此复杂的内容,但笔者仍然将寄存器设计分为两种寄存器,一种是临时数据寄存器,一种是特殊寄存器.

其中,临时数据寄存器本质上就是之前提到的元数据,它与堆栈中的元数据并没有别的区别,访问临时寄存器用R+寄存器标号的方式访问,在笔者设计的虚拟机中,每个虚拟机实例一共有16个这样的临时寄存器,用R0\~R15对他们进行访问.

之后是三个特殊寄存器,SP,IP,BP,如果有阅读过汇编代码的读者应该对这三个寄存器再熟悉不过了,SP永远指向栈顶,IP寄存器指向当前正在执行的指令,BP更多是为了支持函数调用中寻找参数的偏移地址用的,提前将它加进来为后期设计高级语言的编译器做下准备

这三个特殊寄存器都是dword类型,这意味这我们的虚拟机最大的寻址范围是4GB.

堆栈数据结构

在虚拟机的堆栈是由元数据构建起来的,当然,栈的增长方向为高地址向低地址,而堆的方向则是低地址到高地址

在StoryVM中,一般使用GLOBAL[索引号]访问堆栈的元数据,一般使用LOCAL[索引号]来访问栈数据

当然

GLOBAL[BP+i]和LOCAL[i]是等价的,LOCAL表示在偏移量加上一个BP寄存器的值,主要用来访问参数和临时变量.

虚拟机是如何运行的

实际上不仅仅是虚拟机,目前我们见到的大部分的计算机架构都可以把程序当做一张很长的写满指令的纸条,而计算姬要做的就是从头读到尾,并从头执行到尾,我们的虚拟机同样遵循着这样的”执行守则”

当一个脚本被编译为指令流后,虚拟机依次读取一条指令然后执行,当然,指令也并不是完全按照顺序读取,因为指令当中也包含一些”跳转”指令,这将会让虚拟机”跳转”到纸条的其它地方执行指令.

当然,虚拟机设计是一个庞大的需要深思熟虑的系统,如果考虑IO(输入输出)及中断,多线程的线程调度的话,我们无法简简单单用一个字条来描述一个虚拟机的执行过程,但是在文章的开始,初学者依照这个比喻,对虚拟机是如何运行的有个初步的概念.

虚拟机指令集设计

千里之行始于足下,MOV指令设计

笔者在最初设计StoryVM的时候,指令只有短短的几条,一个指令集的完善,不能仅仅是靠初期想当然的脑补,在StoryVM部署到实际的项目之后,笔者再不断去添加那些需要的指令,当然,在本文当中笔者并不打算演示所有的指令实现,笔者决定挑选几个非常具有代表性的指令进行讲解,当然,首当其冲的就是mov这条指令,这也就是为什么本章笔者并不把标题起为虚拟机指令设计,笔者认为,有几个特殊指令是值得专门花费一章节去讲解的.

那么,MOV指令是怎么回事,有什么用呢

其实非常简单的说法,这是一个数据传送(赋值)指令,比如下面的算式

i = 314

就是把变量i赋值为314

当然,如果把这条语句写为StoryVM的汇编代码形式,那么就是

MOV\ i,314

当然,i在汇编中并不存在,假设它是一个全局变量,那么它应该在堆中,假设它在GLOBAL[0]的位置,那么,应该写成

MOV\ GLOBAL\lbrack 0\rbrack,314

这样,GLOBAL[0]就被正式赋值为一个整数,为314,当然看到这里,你应该会觉得MOV指令非常简单,例如,下面的汇编语句即使笔者不说读者也很容易理解要表达的意思

MOV R1,123 //R1寄存器赋值为123

MOV R2,3.14 //R2寄存器赋值为3.14

MOV R3,”Hello World” //R3寄存器赋值为字符串”Hello World”

MOV R4,\@0102\@//R4寄存器赋值为两字节长度的0x01 0x02

上面的语句没什么问题,其中,R1和寄存器R2顺利地被赋值到了元数据寄存器中,但是R3和R4不得不提及一下,当一个元数据被赋值为一个字符串和数据流类型时,不可避免地涉及到了内存分配的问题,但还好,这实现起来并不复杂,当一个寄存器被赋值为了字符串或者数据流类型时,从内存池中划出一块内存将字符串或数据类型存储进去,然后这个元数据中指定一个字符串指针指向它就行了.

那么我们来看看下面的两个语句

MOV R1,123

MOV R1,”Hello”

先将寄存器R1赋值为123,然后再将字符串赋值到寄存器R1中(在内存池申请内存,然后将元),这没什么问题,但是我们将两个语句换一下,那么问题就来了

MOV R1,”Hello”

MOV R1,123

首先,R1寄存器被赋值为”Hello”,在这之后,它又被赋值为123,这将会带来一个问题,如果将R1直接赋值为123,为字符串hello在内存池分配的空间将得不到释放,因此,当一个字符串或是数据流时,在内存池分配的空间都应该被释放

MOV指令和内存管理机制

从上一章节MOV的讨论中我们可以看出当一个元数据由一种类型变换为另一种类型时,一是可能伴随着内存的分配,既然有了分配那就应该有回收机制,例如当一个元数据由int类型变为了string类型,那么,在内存池中必须申请一块内存区域用于存储字符串类型,而由string类型变为了int类型,将伴随着string类型所占用的内存释放,也就是内存的回收,那么在什么时候内存需要分配而什么时候需要回收呢,笔者总结了以下几种情况

当一个数据由其他类型变为了string或者是memory类型时,需要在内存池中为其分配内存空间.
当一个数据进行拷贝时,需要为其分配内存空间

即如下代码

MOV R1,”ABC”

MOV R2,R1 //需要为R2分配内存以进行字符串类型的拷贝

当一个元数据由string或memory类型变为其它类型时,当然,这也包括string类型变为memory或者是memroy类型变为了string类型,需要对原内存进行回收
当一个元数据的长度发生改变时,例如下面语句

MOV R1,”Hi”

MOV R1,”Hello”

那么,R1所在的字符串所在内存可能因为字符串长度的改变需要进行重新分配,需要分配与回收

最后需要提及的一点是,当MOV指令对特殊寄存器进行操作时,不涉及内存的分配与回收机制,毕竟在StoryVM中,特殊寄存器(SP

BP

IP)都是int类型,如果将特殊寄存器赋值为其它类型,虚拟机将会抛出一个异常并结束运行.

因为采用了这种”元数据”的存储方式,对于字符串及数据流类型,不可避免地就需要好好思考下如何管理内存了,毕竟内存泄漏在虚拟机的执行过程中是决不允许的,谁也不希望自己的程序跑着跑着内存就被一点点吃光最后导致崩溃.这种内存管理机制我们常常称之为GC(garbage

collection 垃圾回收机制)

不过在StoryVM中,我们只要遵循并注意这个”元数据”的类型切换时内存的管理就可以避免内存泄漏了,除此之外我们也注意到了,内存的回收分配机制,是一个非常耗费性能的调度机制,并且优化的难度大且难以避免,这也难怪在网上经常看得到对java这种重度依赖GC的语言被各种的吐槽,不过幸好在StoryVM中我们使用的是自行架构的内存池方案,避免了直接使用malloc/free等需要syscall的API额外调用开销.

当然,不仅仅是mov指令,所有对元数据造成修改(不管它是寄存器还是堆栈中的元数据)的指令我们都需要遵循上述的gc规则进行管理,否者结果必定是灾难性的,笔者使用mov指令做”抛砖引玉”之用,是因为Mov指令太具有代表性了,这个看上去最简单的指令,其实现却是storyVM中最复杂的指令,不过读者们也无需担心,在mov指令设计完成后,剩下的指令要设计起来就简单多了.

运算中的隐式转换

如果说让个小学生做个加减乘除运算,想必并也并不是什么复杂的事情,但在StoryVM上,我们考虑的就有点多了.

首先我们先来看看下面两个表达式

1+1=2

1+1.0=2.0

在数学的意义上,1和1.0是等价的,上面两个表达式同样是个等价的表达式运算,但是,在计算机当中,数字的不同表示方式可能导致截然不同的运算规则,首先,整数和浮点数的编码在计算机中是不同的这也就意味着

1+1是一个整数运算而1+1.0是一个浮点类型的运算

出于精度的考虑,在计算的结果中我们会以精度更高的表达方式进行表达,因此.当一个整数和一个浮点数进行运算后,它的结果也是一个浮点数.这点在StoryVM中需要被认真的考虑,与此同时的,在编程开发时,我们也常常使用的到浮点截断(去掉小数点后面的数值),因此,必须也设计相应的指令,将浮点数转换成整数,或者是将一个整数转换成浮点数的表示方式

在StoryVM的指令运算设计中,双目运算符(需要两个数字进行运算的操作符)遵循以下的运算规律

整数与整数运算,得到的也是一个整数
整数与浮点数运算,得到一个浮点数
浮点数与浮点数运算,得到一个浮点数

同时,浮点数的编码方式也需要被严格的考虑,如果因为编译环境的不同而导致浮点的编码方式不同,那么脚本在跨平台运行方面就会出现错误,但幸运的是,StoryVM使用C语言进行编写开发,而C语言的编译器基本都使用IEEE

754的标准对浮点数进行编码.

虚拟机中的加减乘除指令

在StoryVM中,参考了x86指令中加减乘除的助记符,加减乘除的汇编指令分别为

ADD SUB MUL DIV

写起来也基本类似,例如要实现1+1=2的这个表达式方式,指令编写如下

MOV R1,1 //寄存器R1赋值为1

ADD R1,1 //R1+1=2

在ADD R1,1指令中,ADD称之为操作码,R1,1称之为操作数,其中R1位操作数1,数字1为操作数2

实际上严格来说,ADD应该称之为加法操作码对应的助记符(mnemonic),R1是寄存器1对应的助记符,1是一个常量,当然,ADD函数遵循着运算隐式转换的规则,如果指令改为

ADD R1,1.0

那么寄存器R1对应的元数据类型也会相应的转换为一个浮点数据类型.

如果汇编器将ADD,R1,1这个指令编译成指令流,那么,它应该是下面这个样子的

参照之前提到的编码格式,其对应的指令流为0x02 0x02 0x01 0x00 0x00000001

0x00000001一共12字节.

下面,我们用opcode表示操作码.op1表示操作数1,op2表示操作数2,GLOBAL表示接受堆数据数据类型,LOCAL表示接受栈数据数据类型,REG表示接受寄存器数据类型,int,float,string,memory分别表示接受整形,浮点型,字符串型和数据流型常量.num表示接受一个数字,即可是是浮点类型也可是整数类型.

例如减法指令sub的描述如下

减法指令,op1=op1-op2,将操作数1的值减去操作数2的值,然后将结果赋值给操作数1

当然,操作数1必须是一个寄存器或者是堆栈中的元数据,因为常量不能被赋值,操作数2可以是一个寄存器或者堆栈中的元数据或者一个数字常量都可.

sub [reg,local,global],[num,reg,local,global]

依次类推,那么,在StoryVM中,几个运算指令的描述如下(为了说明方便,后面的表达式用C语言的运算符进一步描述)

add

加法指令,op1=op1+op2

add [reg,local,global],[num,reg,local,global]

sub

减法指令,op1=op1-op2

sub [reg,local,global],[num,reg,local,global]

neg

符号求反指令,op1=-op1

neg [reg,local,global]

div

除法指令,op1=op1/op2

div [reg,local,global],[num,reg,local,global]

mul

乘法指令,op1=op1*op2

mul [reg,local,global],[num,reg,local,global]

mod

余数指令,两个操作数必须为整数 op1=op1%op2

mod [reg,local,global],[int,reg,local,global]

shl

左移位指令,两个操作数必须为整数 op1=op1\<\<op2

shl [reg,local,global],[int,reg,local,global]

shr

右移位指令,两个操作数必须为整数 op1=op1\>\>op2

shr [reg,local,global],[int,reg,local,global]

and

与运算指令,op1=op1&op2

and [reg,local,global],[num,reg,local,global]

或运算指令,op1=op1|op2

or [reg,local,global],[num,reg,local,global]

xor

异或运算指令op1=op1\^op2

xor [reg,local,global],[num,reg,local,global]

inv

位取反指令,op1=\~op1

inv [reg,local,global]

not

逻辑非指令 op1=!op1

not [reg,local,global]

andl

逻辑与指令 op1=op1&&op2

andl [reg,local,global],[num,reg,local,global]

orl

逻辑或指令 op1=op1||op2

andl [reg,local,global],[num,reg,local,global]

pow

阶乘指令(op1为底数,op2为指数,结果在op1中) op1=op1_op2

pow [reg,local,global],[num,reg,local,global]

sin

正弦函数op1=sin(op2)

sin [reg,local,global],[num,reg,local,global]

cos

余弦函数 op1=cos(op2)

cos [reg,local,global],[num,reg,local,global]

int

强制类型转换为int型(原类型float)

int [reg,local,global]

flt

强制类型转换为float型

flt [reg,local,global]

条件跳转指令

相比于可能修改元数据需要小心翼翼管理内存的指令,条件跳转指令的实现可就简单的多了,唯一需要注意的是,如何确定跳转的位置,在x86指令集中,跳转指令的设计就复杂的多了,有近跳转,远跳转,相对跳转和绝对跳转,但是在StoryVM中,跳转指令并不需要设计的那么复杂,所有的跳转指令都为绝对跳转.

在StoryVM中,使用JMP指令表示一个无条件跳转指令,例如

JMP 10表示程序跳转到地址为10的位置执行

这么设计当然没有一点问题,但是我们不可能在编写程序时,手工去计算我们要跳转的位置,那么问题就是如何确定跳转的地址了,幸运的是,每条指令的长度都可以很方便的进行计算,我们只需要设计一个标志,就可以很容易计算出标志所在的地址了

在StoryVM中,标志的表示方式是一个助记符加上一个冒号,例如

FLAG:

MNEMONIC:

ADDR:

TRUE:

都是合法的标志类型,很多时候为了表现这是一个函数,在标号前可以加入描述符FUNC

例如

FUNC FLAG:

和

FLAG是等价的,FUNC这个助记符对源代码没有任何的影响,只是为了代码方便查看及分类添加的一个没有意义的关键字

现在观察下面的指令

MOV R1,1 //长度为12字节

ADD R1,2 //长度为12字节

FLAG: //偏移地址为24

ADD R1,2//长度为12字节

JMP FLAG//跳转到FLAG处开始执行

需要注意的一点是,如果一个汇编程序从开始编译到结束,那么,标号必须在JMP指令之前,也就是说JMP必须是向前跳转的,这显然不符合一个跳转指令应该具有的功能,要解决这一个问题实际也并不复杂,在汇编指令的编译期间,对源代码进行两次扫描,第一次扫描确定所有的标号对应的位置,第二次扫描才将JMP指令”连接”到对应的标号中实现跳转,

除了无条件跳转指令,当然还有一系列的跳转指令,具体描述如下

条件跳转,当op1等于op2,跳转到op3

je [num,string,reg,local,global],[num,string,reg,local,global],[reg,int,local,global,label]

jne

条件跳转,当op1不等于op2,跳转到op3

jne [num,string,reg,local,global],[num,string,reg,local,global],[reg,int,local,global,label]

条件跳转,当op1小于op2,跳转到op3

jl [num,string,reg,local,global],[num,string,reg,local,global],[reg,int,local,global,label]

jle

条件跳转,当op1小于等于op2,跳转到op3

jle [num,string,reg,local,global],[num,string,reg,local,global],[reg,int,local,global,label]

条件跳转,当op1大于op2,跳转到op3

jg [num,string,reg,local,global],[num,string,reg,local,global],[reg,int,local,global,label]

jge

条件跳转,当op1大于等于op2,跳转到op3

堆栈操作指令

堆栈操作本身属于数据结构的一种,当然,堆栈的操作和特殊的寄存器SP,BP相关,就和我们之前说的那样LOCAL[i]和GLOBAL[BP+i]是等价的,而SP指令和

PUSH

POP

两个指令相关

PUSH x指令实际上和下面的指令等价

SUB SP,1

MOV GLOBAL[SP],x

也就是说,每当执行一条PUSH指令,SP寄存器的值会被减去1,然后将PUSH的值赋值到对应的堆空间GLOBAL[SP]中

而POP x指令和PUSH指令刚好相反,其等价于

ADD SP,1

MOV x,GLOBAL[SP]

在指令的编写及设计中,PUSH指令和POP指令常常是成对出现的,也就是我们常常说的要保证堆栈平衡,如果PUSH

POP不成对出现,往往容易导致内存泄漏,越界访问等异常现象.

函数跳转指令

实际上虚拟机有上述指令就已经可以完成大部分的工作了,但除了一般的跳转指令,在StoryVM中还设计了一个特殊的指令CALL指令,CALL指令本身并没有什么特别的地方,它的作用是将下一条指令的地址压栈,然后跳转到目的标号中,CALL指令的设计同样是一种数据结构上的调度处理,当我们为这个汇编语言设计高级语言编译器的时候,CALL指令就会被经常的用到.

StoryVM指令表

介绍完几种关键的指令后,最后贴上StoryVM所支持的所有指令集,读者可以参照这些指令自行实现

mov

赋值指令,将op2的值赋值给op1

mov [reg,local,global],[num,string,reg,local,global]

add

加法指令,op1=op1+op2

add [reg,local,global],[num,reg,local,global]

sub

减法指令,op1=op1-op2

sub [reg,local,global],[num,reg,local,global]

neg

符号求反指令,op1=-op1

neg [reg,local,global]

div

除法指令,op1=op1/op2

div [reg,local,global],[num,reg,local,global]

mul

乘法指令,op1=op1*op2

mul [reg,local,global],[num,reg,local,global]

mod

余数指令,两个操作数必须为整数 op1=op1%op2

mod [reg,local,global],[int,reg,local,global]

shl

左移位指令,两个操作数必须为整数 op1=op1\<\<op2

shl [reg,local,global],[int,reg,local,global]

shr

右移位指令,两个操作数必须为整数 op1=op1\>\>op2

shr [reg,local,global],[int,reg,local,global]

and

与运算指令,op1=op1&op2

and [reg,local,global],[num,reg,local,global]

或运算指令,op1=op1|op2

or [reg,local,global],[num,reg,local,global]

xor

异或运算指令op1=op1\^op2

xor [reg,local,global],[num,reg,local,global]

inv

取反指令,op1=\~op1

inv [reg,local,global]

not

逻辑非指令 op1=!op1

not [reg,local,global]

andl

逻辑与指令 op1=op1&&op2

andl [reg,local,global],[num,reg,local,global]

orl

逻辑或指令 op1=op1||op2

andl [reg,local,global],[num,reg,local,global]

pow

阶乘指令(op1为底数,op2为指数,结果在op1中) op1=op1_op2

pow [reg,local,global],[num,reg,local,global]

sin

正弦函数op1=sin(op2)

sin [reg,local,global],[num,reg,local,global]

cos

余弦函数 op1=cos(op2)

cos [reg,local,global],[num,reg,local,global]

int

强制类型转换为int型(原类型float)

int [reg,local,global]

flt

强制类型转换为float型

flt [reg,local,global]

strlen

字符型长度指令

op1=strlen(op2)

strlen [reg,local,global],[reg,local,global,string]

strcat

字符型拼接指令

strcat(op1,op2)

strcat [reg,local,global],[int,reg,local,global,string]

strrep

字符串替换函数

将op1存在的op2字符串替换为op3中的字符串, 注意:op2 op3必须为字符串类型

strrep [reg,local,global],[reg,local,global,string],[reg,local,global,string]

strchr

将op2在索引op3中的字存储在op1中, 注意:op2必须为字符串类型

strchr [reg,local,global],[reg,local,global,string],[reg,local,global,int]

strtoi

将op2转换为整数保存在op1中,注意:op2必须为字符串类型

strtoi [reg,local,global],[reg,local,global,string]

strtof

将op2转换为浮点数保存在op1中,注意:op2必须为字符串类型

strtof [reg,local,global],[reg,local,global,string]

strfri

将op2整数类型转换为字符串类型保存在op1中

strfri [reg,local,global],[reg,local,global,int]

strfrf

将op2浮点类型转换为字符串类型保存在op1中

strfrf [reg,local,global],[reg,local,global,float]

strset

将op1所在字符串索引为op2 int的字符置换为op3

如果op3为一个int,则取asc码(第八位1字节),如果op3为一个字符串,则取第一个字母

strset [reg,local,global],[reg,local,global,int],[reg,local,global,string,int]

strtmem

将op1字符串类型转换为内存类型

strfrf [reg,local,global]

asc

将op2的第一个字母以asc码的形式

asc [reg,local,global],[reg,local,global,string]

membyte

将op3 内存类型对应op2索引复制到op1中,这个类型是一个int类型(小于256)

membyte [reg,local,global],[reg,local,global,int],[reg,local,global,memory]

memset

设置op1对应op2索引的内存为op3

memset [reg,local,global],[reg,local,global,int],[reg,local,global ,int]

memtrm

将op1内存进行裁剪,其中,op2为开始位置,op2为大小

memcpy [reg,local,global],[reg,local,global,int],[reg,local,global,memory]

memfind

查找op2对应于op3内存所在的索引位置,返回结果存储在op1中,如果没有找到,op1将会置为-1

memfind [reg,local,global],[reg,local,global,memory],[reg,local,global,memory]

memlen

将op2的内存长度存储在op1中

memlen [reg,local,global],[reg,local,global,memory]

memcat

将op2的内存拼接到op1的尾部

memcat [reg,local,global],[int,reg,local,global,memory]

memtstr

将op1内存类型转换为字符串类型,如果op1的内存结尾不为0,将会被强制置为0

memtstr [reg,local,global]

datacpy

复制虚拟机data数据,从地址op2到地址op1,长度为op3

datacpy [reg,local,global,int], [reg,local,global,int], [reg,local,global,int]

jmp

跳转指令跳转到op1地址

jmp [reg,num,local,global,label]

条件跳转,当op1等于op2,跳转到op3