- PDF 免费下载

Size: px

Start display at page:

Download ""

塔稚衅
5 years ago
Views:

1 华中科技大学计算机科学与技术学院编译原理大型项目训练报告题目 : 一个面向对象的类 java 的编译器的设计与实现专业 : 计算机科学与技术班级 : 计科卓工 1201 学号 : U 姓名 : 朱凡成绩 : 指导教师 : 徐丽萍完成日期 : 2015 年 7 月 7 日

2 目录一. 实验概述实验要求实验完成情况概述分工情况...3 二. 作用域的处理函数作用域函数作用域生成汇编代码局部作用域三. 变量和常量的定义全局变量与静态变量的定义局部变量的定义临时变量的定义成员变量的定义字符串常量的定义其他常量的定义...23 四. 普通变量和普通函数的使用普通变量的使用普通函数的调用...27 五. 成员变量与成员函数的使用以及多态的实现成员变量的使用成员函数的调用以及多态的实现六. 生成汇编代码 new 语句生成汇编 return 语句生成汇编七. 生成可执行程序八. 实验感想... 39

3 一. 实验概述 1.1 实验要求项目内容 : 自定义一个语言的文法规则, 或采用 C 语言 ( 或 C++ 语言或 C# 语言或 JAVA 语言 ), 利用课程实验的结果构造一个 SC 语言的编译程序甚至集成开发环境任务要求 : 收集与阅读相关文献资料, 确定采用的技术线路, 设计系统方案, 完成系统实现 ; 提交标准格式打印的编译原理大型项目训练报告和包括编译原理大型项目训练报告编译器源程序编译器目标程序和测试模拟数据文件之光盘语言要求 : SC 语言可以是 C 语言的子语言, 要求至少包含的语言成分如下, 具体语言范围自行确定 ; 1. 数据类型至少包括 char 类型 int 类型和 float 类型 2. 基本运算至少包括算术运算比较运算自增自减运算和复合赋值运算 3. 控制语句至少包括 if 语句和 while 语句 1.2 实验完成情况概述在本次课程设计中, 我和孟嘉豪同学一起实现了一个 SimpleJava 编译器我们在 C 语言语法的基础上进行了一些修改, 最终实现了 SimpleJava 的语法, 具体语法如下所示 : 1. 去掉了 C 语言中的指针 2. 去掉了结构和联合 3. 去掉了枚举类型 4. 数组还没来得及实现 5. 增加了类, 可以单继承, 可以多态成员函数的多态更加类似于 java, 而非 C++, 所有的成员函数都是虚函数, 不需要 virtual 关键字所有的成员函数和成员变量都是 public, 继承也是 public, 不支持 private 和 protected 6. 普通变量可以使用 static 关键字, 但是成员变量和成员函数不支持 static 关键字 7. 类没有构造函数和析构函数, 对象通过 new 关键字来构造, 通过 delete 关键 1

4 字来释放内存 8. 不支持重载 9. 在 SimpleJava 的程序中可以直接调用 C 语言的库函数, 所以输出可以直接使用 printf 10. 实现了 if 和 while, 没有实现 for 和 switch 11. 浮点运算的支持并不完善就 SimpleJava 的语法, 我有三个地方需要额外说明 : 1. 关于函数重载的问题函数重载的实现其实是很简单的, 只要在最终的汇编代码中改一改函数的名字即可但是我们没有实现重载, 这主要是因为我们的编译器最终产生的目标文件要和 C 语言的库函数兼容如果实现重载的话, 那么最终汇编代码中函数的命名无法兼容 C 语言, 最终会导致没有办法在 SimpleJava 中调用 C 的库函数 2. 关于库函数的问题一般来说, 每一种语言都需要附带一个相应的标准函数库比如说 C 语言有 glibc,c++ 有 STL 等等标准函数库封装了一些系统调用, 比如说输入输出, 方便了用户的使用但是, 由于 SimpleJava 的函数调用方式和 C 语言是兼容的, 所以不需要额外为它去写一个标准函数库, 只需在 SimpleJava 中直接使用 C 语言的库函数, 然后汇编得到目标代码后与 glibc 链接即可这大大的减轻了我们的工作量 3. 浮点运算的问题对于 gcc 来说,32 位版的 gcc 的浮点运算是通过用整数运算模拟实现的, 这主要是为了兼容 386CPU(386 是没有浮点运算单元的, 浮点预算单元是从 486 以后才开始有的 ), 而 64 位版的 gcc 则是直接使用浮点指令来进行浮点运算, 这毫无疑问大大加快了浮点运算的速度而对于我们的 SimpleJava 编译器来说, 虽然最终生成的是 32 位的汇编, 但是浮点运算确实用浮点指令实现的, 毕竟我们不用考虑 386 的不兼容问题但是, 由于我们的中间代码没有设计好, 所以对浮点运算的支持还是有问题 ( 因为浮点寄存器是栈式寄存器, 只能对栈顶的寄存器进行操作, 和普通寄存器不一样 ) 最终, 源文件经过我们的编译器处理后, 会生成汇编文件 out.s 我们使用的是 X86 平台上的 32 位汇编然后, 使用 gnu 的汇编器 gas 处理汇编文件, 生成目标代码 out.o, 最后用连接器 ld 将 out.o 和 C 语言标准库 glibc 链接即可生成最终的可执行文件 2

5 1.3 分工情况编译器的标准工作流程如下所示 : 词法分析语法分析表格管理语义分析出错处理中间代码生成代码优化目标代码生成以上是编译器的标准工作流程, 我们的 SimpleJava 编译器对这个过程做了一些修改, 工作流程如下所示 : 3

6 Lex 进行词法分析 Yacc 进行语法分析, 生成语法树遍历语法树, 生成符号表数, 同时, 在符号表中插入中间代码遍历符号表树, 生成汇编代码如上所示, 在整个编译过程中, 有两棵树是最为重要的, 贯穿了整个编译过程 : 一棵是 yacc 进行语法分析后生成的语法树, 另一棵是以代码中的作用域为节点, 包含了符号和中间代码的符号表树关于上述过程, 我有以下几点需要额外说明 : 1. 关于符号表在 SimpleJava 的工作流程中, 只需遍历一遍语法树, 便可同时生成符号表树, 符号表树中的符号, 以及中间代码至于这是如何做到的, 我将在后面具体叙述 2. 关于语义分析在 yacc 程序中所定义的语法规则其实是相当宽泛的, 如果一个源程序成功的通过了语法分析, 生成了语法树, 那么这个源程序还是不一定正确的, 比如下面这条声明语句 : Int float a; 4

7 这条语句是可以通过语法分析的, 但它依旧还是错误的所以当源代码通过语法分析生成语法树后, 还需进一步遍历语法树, 对语法树的结构进行检验, 这就是语义分析在 SimpleJava 的工作流程中, 我们并不会单独的去为语义分析去遍历一边语法树, 而是将语义分析的工作糅杂在了生成符号表和中间代码的过程中正如前面所说, 我们只需遍历一遍语法树便完成了所有的工作 3. 关于出错处理我们有单独用于处理错误信息输出的类 LogiMsg, 如下图所示 : 但是却没有一个统一的错误处理表, 错误处理语句分散在整个程序中这也是我们不足的一个地方不过这也是没有办法的事, 毕竟没有做之前我们根本不知道可能会报怎样的错误 5

8 分工情况 : 由于编译器这个东西具有高度的整体性, 前后过程之间衔接密切, 并不好进行模块的划分, 所以我和孟嘉豪的工作有很多重叠的地方不过总的来说, 孟嘉豪做的是前端, 我做的是后端我认为我的工作是如何将 SImpleJava 语言和汇编语言对应起来, 比如说如何为不同类型的变量分配空间, 如何处理普通函数和成员函数, 如何使用成员变量, 如何实现多态这些其实都要在符号表中进行反映, 最后在遍历符号表时生成对应的汇编语句我在实验报告接下来的部分将对这些问题进行重点阐述另外, 我不会按照编译器的工作流程去写这个实验报告 ( 比如说, 先写符号表, 再写汇编的生成 ), 我会分成不同的专题去写, 每一个专题阐述一个重要的问题, 每个专题都会包含编译器工作的不同阶段, 我觉得这样写思路会比较清晰 6

9 二. 作用域的处理 SimpleJava 语言是一个面向对象的语言, 但是首先它一定是一个结构化的语言, 整个源程序都是由一层一层的作用域组成, 所有的可执行语句都一定存在于某个作用域中, 不存在游离的可执行语句在整个源程序的结构中, 最上层的是全局作用域, 然后是类作用域和和普通函数作用域, 类作用域下面还有成员函数作用域, 然后最下面则是局部作用域, 也就是代码块整个作用域的结构如下所示 : SCOPE_GLOBAL SCOPE_GLOBALFUNC SCOPE_CLASS SCOPE_CLASSFUNC SCOPE_LOCAL 对于全局作用域来说, 它里面不能有可执行语句, 只有声明语句, 而在全局作用域声明的变量则是全局变量我把全局变量放在汇编的 bss 段, 然后使用变量名进行访问对于类作用域来说, 它包括成员变量和成员函数作用域其实类在汇编代码里并没有直接对应的部分, 因为成员变量不需要在汇编代码里进行额外的表示, 只需在生成对象时预留空间即可, 而成员函数则是当做普通函数进行处理, 只不过命名有所不同下面我将着重阐述函数作用域和局部作用域 7

10 2.1 函数作用域前面已经说到, 函数分为成员函数和普通函数, 这两者具有不同的作用域类型但是对他们的处理基本上是一样的, 所以我把他们放在一起来说最终生成的汇编代码分为三个段 : 1.data 段 : 放字符串常量 2.bss 段 : 放全局变量和静态变量 3.text 段 : 也就是代码段, 放的是汇编指令最终, 函数就放在代码段中, 每一个函数对应代码段的一个标号以及该标号后面的语句例如, 现在有函数 : int func() int a; Int b; a=b+1; return a; 那么他在代码中对应的汇编代码就应该是 : func: pushl %ebp... 在比如说现在有成员函数 : class a int func() int a; Int b; a=b+1; return a; 8

11 那么他在代码段中对应的汇编代码就应该是 : A_func: pushl %ebp... 从上面的例子中, 可以看出两点 : 1. 对于普通函数, 它在汇编中对应的标签名就是函数名, 这同时也是 C 语言的命名规则在 SimpleJava 编译器中, 函数的命名规则和参数的传递方式都和 C 语言是一样的这样, 在 SimpleJava 的源程序中就可以直接调用 C 语言的库函数 ( 比如说 printf) 来进行输入输出 2. 对于成员函数, 它在汇编中对应的标签名是类名加下划线加函数名从例子中可以看出, 成员函数和普通函数的在汇编中的处理是一样的, 类在汇编代码中并没有直接的对应关系当然, 也可以说类反应在了成员函数的名字上对于下面的函数 : int func(int c, int d) int a; Int b; a=b+1; return a; 它在符号表中生成了两个作用域节点 : 一个普通函数作用域和一个局部作用域, 函数作用域是局部作用域的父节点 ( 符号表的结构由孟嘉豪进行说明, 我在这里就不赘述了 ) 前面已经说过, 符号表是在遍历语法树的过程中生成的, 当遍历语法树时碰到 T_CFUNCDEF_DECTIONSFS_DECTOR_COMPSTM 类型的节点, 就知道这里是一个函数的定义, 然后就在符号表中添加一个函数作用域节点, 代码如下 : Scope::pushScope(Scope::s_curScope, tmpscope); Scope::setCurScope(tmpScope); 至于说局部作用域, 在 SimpleJava 中, 一个花括号就是一个局部作用域, 遍历语法树时, 碰到一个花括号节点, 即类型为 T_CCOMPSTM_STMLIST 的节点时, 9

12 就会在符号表中添加一个局部作用域节点也就是说, 一个函数至少对应了一个函数作用域和一个局部作用域其实可以看到, 函数作用域中存放的仅仅只有该函数的参数, 局部变量以及可执行语句都放在局部作用域中函数作用域生成汇编代码函数作用域中存放的符号仅仅只有该函数的参数, 并且没有存放中间代码, 而函数参数属于局部变量, 应在栈中为其分配空间但是函数作用域对应的汇编代码中是不需要为其分配空间的, 因为在调用函数时会将参数压栈, 此时就已经为函数的参数分配了空间遍历符号表树生成汇编代码时, 若碰到函数作用域, 只需按照前面的命名规则生成对应的标签即可, 同时, 还需在最后加上 ret 语句, 代码如下所示 : else if (scope_t->scopetype == Scope::SCOPE_GLOBALFUNC) string a = scope_t->getscopename() + ":\n"; addtotextsectionlist(a); vector<scope *>::iterator childitr; for (childitr=scope_t->childs.begin(); childitr!=scope_t->childs.end(); childitr++) Asm::printScopeAsm(*childItr); addtotextsectionlist("\tret\n"); else if (scope_t->scopetype == Scope::SCOPE_GLOBALFUNCCHAN) string a = scope_t->getscopename() + ":\n"; addtotextsectionlist(a); 10

13 vector<scope *>::iterator childitr; for (childitr=scope_t->childs.begin(); childitr!=scope_t->childs.end(); childitr++) Asm::printScopeAsm(*childItr); addtotextsectionlist("\tret\n"); else if (scope_t->scopetype == Scope::SCOPE_CLASSFUNC) if (scope_t->parent == NULL) LogiMsg::logi("error in printscopeasm there is no class \n"); return ; string a = scope_t->parent->getscopename() + "_" + scope_t->getscopename() + ":\n"; addtotextsectionlist(a); vector<scope *>::iterator childitr; for (childitr=scope_t->childs.begin(); childitr!=scope_t->childs.end(); childitr++) Asm::printScopeAsm(*childItr); addtotextsectionlist("\tret\n"); 11

14 2.2 局部作用域在 SimpleJava 语言中, 局部作用域无处不在, 一对花括号就是一个局部作用域它可以是函数定义的函数体, 也可以同 if 或者是 while 语句一起使用局部作用域在语法树中对应的节点类型是 T_CCOMPSTM_STMLIST 所有的局部作用域所对应的汇编代码都是一样的在进入局部作用域时, 需要保存 ebp 指针, 然后以 ebp 指针为局部变量访问的起始点, 然后移动 esp 指针, 为局部变量留出空间比如某一局部作用域的局部变量的空间为 12 字节, 那么进入该作用域时对应的汇编代码为 : pushl %ebp movl %esp, %ebp subl $12, %esp 我使用函数 genfuncstart 来生成进入局部作用域时所需要的汇编代码, 如下所示 : void Asm::genFuncStart(Scope *scope_t) //textsection << "\tpushl %ebp\n"; //textsection << "\tmovl %esp, %ebp\n"; //textsection << "\tsubl $" << scope_t->totalbytesize-scope_t->curstartoffset << ", %esp\n"; addtotextsectionlist("\tpushl %ebp\n"); addtotextsectionlist("\tmovl %esp, %ebp\n"); string a; stringstream ss; string b; ss << scope_t->totalbytesize-scope_t->curstartoffset; ss >> b; a = "\tsubl $" + b + ", %esp\n"; addtotextsectionlist(a); 在离开局部作用域时, 则需要回复 esp 指针, 释放为局部变量预留的空间, 然后再回复 ebp, 汇编代码如下 : movl %ebp, %esp popl %ebp 12

15 我使用函数 genfuncend 来生成进入局部作用域时所需要的汇编代码, 如下所示 : void Asm::genFuncEnd(Scope *scope_t) /*textsection << "\tmovl %ebp, %esp\n"; textsection << "\tpopl %ebp\n";*/ addtotextsectionlist("\tmovl %ebp, %esp\n"); addtotextsectionlist("\tpopl %ebp\n"); // addtotextsectionlist("\tsubl $4, %esp\n"); 13

16 三. 变量和常量的定义在 SimpleJava 的源程序中, 存在着各种各样的量, 有变量也有常量变量可以分为 : 全局变量, 静态变量, 局部变量, 临时变量, 成员变量常量可以分为字符串常量, 整形常量, 字符串常量等等下面我将逐一阐述碰到这些量时如何在符号表中表示它们以及它们对应的汇编代码是怎样的 3.1 全局变量与静态变量的定义遍历语法树时, 若遇到类型为 T_CDECTION_DECTIONSFS_INITDECTORLIST 的节点, 则为变量的定义此时, 若当前作用域为全局作用域, 则说明该变量为全局变量, 需要对该变量做标记, 然后加入符号表, 代码如下所示 : if (Scope::s_curScope==Scope::s_globalScope) tmpsymbol->isglobal=true; 若是静态变量, 由于最后遍历符号表时可以通过变量类型进行判断, 所以无需做额外的标记前面已经说过, 最终的汇编代码分为 3 个段, 全局变量和静态变量全部放在 bss 段里比如说现在有全局变量 a 和静态变量 b, 如下所示 : int a; int main() static int b; 那么最终生成的汇编代码应该是这样的 :.section.bss.lcomm a, 4.lcomm b, 4 这段代码的意思是在 bss 段中给 a 和 b 各留 4 字节的空间当最终遍历符号表生成汇编时, 首先遍历全局作用域的符号, 在汇编中生成全局变量, 然后在遍历各个局部作用域前, 首先遍历该作用域的符号表, 在汇编中 14

17 生成静态变量, 代码如下所示 : 生成全局变量 : list<symbol *>::iterator symitr; stringstream ss; for (symitr=scope::s_globalscope->symbolseqlist.begin(); symitr!=scope::s_globalscope->symbolseqlist.end(); symitr++) string a; ss.clear(); string b; ss << (*symitr)->getbytesize(); ss >> b; a = "\t.lcomm " + (*symitr)->getsymbolname() + ", " + b + "\n"; addtobsssectionlist(a); 生成静态变量 : for (staitr=scope_t->symbolseqlist.begin(); staitr!=scope_t->symbolseqlist.end(); staitr++ ) if ((*staitr)->typeclass.storagetype & TypeClass::STOR_STATIC) string a; ss.clear(); string b; ss << (*staitr)->getbytesize(); ss >> b; a = "\t.lcomm " + (*staitr)->getsymbolname() + ", " + b + "\n"; addtobsssectionlist(a); 15

18 其实, 局部变量和静态变量也可以放在数据段 ( 即 data 段 ) 中, 但是, 我还是把他放在了 bss 段这是因为, 若放在 bss 段, 那么最终生成可执行文件时, 该数据不会占用空间,bss 段的空间在运行时由操作系统分配这样一来, 便可以减少可执行文件的大小 3.2 局部变量的定义在早期的 C 语言中, 局部变量的定义一定要在可执行语句之前, 我们的 SimpleJava 沿用了这种做法这里的局部变量包含了函数的参数局部变量的内存空间分配在栈中在符号表中定义局部变量时, 最重要的是记录该局部变量的偏移量, 因为访问局部变量时是通过偏移量来访问的由于存在嵌套的问题, 即在内层的作用域中可以访问外层的局部变量, 所以在计算偏移量时一定要考虑这个问题那么偏移量的计算应当从哪里开始呢? 毫无疑问应当从函数定义开始因为整个 SimpleJava 的源程序都是由一个一个函数组成, 并且函数外面没有局部变量, 只有全局变量在描述作用域的 Scope 类中, 我引入了两个变量 curstartoffset 和 totalbytesize curstartoffset 记录该作用域的起始偏移量,totalByteSize 等于 curstartoffset 加上该作用域的所有局部变量的大小的和对于函数作用域来说,curStartOffset 和 totalbytesize 初始值都为 0, 因为它没有外层作用域而局部作用域的 curstartoffset 和 totalbytesize 的初始值则需要通过它的上层作用域的 totalbytesize 计算得到下面我将通过一个例子来说明计算方法有这样一个函数 : int func(int a, int b) char c; while (1) int d; 这样的一个函数一共有三层作用域 : 最外层的函数作用域, 然后是两层局部作用域进入函数时, 栈的分布是这样的 : 16

19 b a esp eip 然后再进入下层的局部作用域, 栈变成了这样 : b a eip esp ebp c ebp 然后再进入下层作用域, 栈变成了这样 : 17

20 b a eip ebp c ebp ebp esp d 从上面的例子中, 我们可以得到两点结论 : 1. 下层作用域的 totalbytesize 和 curstartoffset 等于上层作用域的 totalbytesize 加 4, 这是因为没进入一个作用域都要保存 ebp 指针 2. 每一层作用域中, 都是以 ebp 指针为基址来访问局部变量确定了每个作用域的 totalbytesize 和 curstartoffset 后, 定义每个变量时就可以确定该变量的偏移量了 : 首先将该作用域的 totalbytesize 增加变量的大小, 然后将 totalbytesize 的值赋给该变量的偏移量代码如下所示 : Scope::s_curScope->incTotalByteSize(tmpsymbol->getByteSiz e()); tmpsymbol->setoffset(scope::s_curscope->gettotalbytesize() ); 特别的, 对于函数作用域中的 Symbol( 即函数参数 ) 的偏移量的计算, 有两个地方需要注意 : 1. 函数参数压栈时是倒着压的, 所以计算偏移量时要倒着算 2. 对于普通函数, 最后 totalbytesize 的值要额外加上 4, 因为调用函数时会自动将 eip 压栈而对于成员函数, 则最后 totalbytesize 的值要额外加上 8, 因为调用成员函数时还需要将 this 指针压栈 18

21 3.3 临时变量的定义当调用函数时, 需要将函数的参数的值作为临时变量保存在堆栈中, 方便传递参数时压栈比如下面这个调用 : a=func(c,b+d); 那么就需要两个 int 型的临时变量其实临时变量和局部变量是一样的, 它们的偏移量的算法完全是相同的只不过定义临时变量时, 有可能已经定义了下层作用域, 所以应当修改下层作用域中的局部变量的偏移量, 将它们全部加上该临时变量的大小, 代码如下所示 : void Scope::scopeOffsetChange(Scope *scope_t, int inc_t) if (scope_t) vector<scope *>::iterator childitr; for (childitr=scope_t->childs.begin(); childitr!=scope_t->childs.end(); childitr++ ) (*childitr)->curstartoffset+=inc_t; (*childitr)->totalbytesize+=inc_t; list<symbol *>::iterator symitr; for (symitr=(*childitr)->symbolseqlist.begin(); symitr!=(*childitr)->symbolseqlist.end(); symitr++) (*symitr)->offset+=inc_t; Scope::scopeOffsetChange((*childItr), inc_t); 19

22 3.4 成员变量的定义对象的引用通过偏移量来访问成员变量, 而计算成员变量的偏移量主要需要考虑的是类之间的继承关系如果一个类没有父类, 那么它的 totalbytesize 的初始值为 0, 然后每增加一个偏移量,totalByteSize 增加对应的大小若一个类有父类, 那么它的 totalbytesize 的初始值等于父类的 totalbytesize 的值这样, 就可以保证子类可以访问父类的成员变量当然, 若子类的变量和父类的变量同名, 那么子类的变量会覆盖父类的变量例如现在有两个类 : class A int a; int b; class B char c; int d; 那么偏移量如下表所示 : 变量偏移量 a 0 b 4 c 8 d 7 20

23 3.5 字符串常量的定义现在有这样一段代码 : printf( %d\n,a); 这里存在字符串常量, 所以需要在符号表和汇编代码中进行表示在汇编代码中, 符号表放在数据段 ( 即 data 段 ) 中, 并且我还会给每一个字符串常量取一个内部的名字.S1,.S2... 比如上面的字符串, 那么它在汇编代码中的表示就是 :.section.data.s1:.asicz %d\n 这样的话就可以通过名字来访问字符串常量比如所调用函数时需要将字符串压栈, 就可以这样 : pushl $.S1 至于将字符串常量加入符号表, 就十分简单了, 直接加入常量的链表即可代码如下所示 : Symbol *rst = Scope::s_globalScope->resolveSymbol(token, Symbol::SYMBOL_STRING_LITERAL); if (NULL == rst) rst = new Symbol(Symbol::SYMBOL_STRING_LITERAL); static int s_string=0; s_string++; string idstring; string tmpname = ".S"; stringstream ss; ss << s_string; ss >> idstring; tmpname +=idstring; rst->setsymbolname(tmpname); rst->addsymbolvalue(token); rst->typeclass.settypesftype(typeclass::sf_int); rst = (0 == Scope::s_curScope->defineSymbol(rst))? NULL : rst; 21

24 s_context->clearcontext(); s_context->tmpoptype = ItmCode::OPR_SYMBOL; s_context->tmpexpsymbol = rst; 在遍历符号表树时, 首先就要将所有的字符串常量转化为汇编代码, 对应的代码如下所示 : for (constitr=scope::s_constmap.begin(); constitr!=scope::s_constmap.end(); constitr++) if (constitr->second->symboltype==symbol::symbol_string_lite RAL) if (constitr->second->symbolvalue.size()!= 1) LogiMsg::logi("error in printallasm, the size of symbolvalue is not 1\n"); return ; string a = constitr->second->getsymbolname() + ":\n\t.asciz " + constitr->second->symbolvalue.at(0) + "\n"; addtodatasectionlist(a); 22

25 3.6 其他常量的定义对于整型常量和字符常量, 遍历语法树时若遇到它们直接加入符号表即可又因为是常量, 所以不需要为它们分配空间, 在汇编代码中可以直接拿来用例如 : 使用整数 : movl $0, %eax 使用字符 : movl $ a, %eax 23

26 四. 普通变量和普通函数的使用本节我将阐述如何在汇编中使用普通变量和调用普通函数成员变量和成员变量的使用将放到下一节 4.1 普通变量的使用如果是使用全局变量或者是静态变量, 由于它们都放在 bss 段, 所以可以直接通过名字来访问例如现在有全局变量 a 和静态变量 b: int a; int main() static int b; 那么最终生成的汇编代码应该是这样的 :.section.bss.lcomm a, 4.lcomm b, 4 访问 a 和 b 的汇编代码是这样的 : movl a, %eax movl b, %ebx 生成汇编的代码 : if (symbol_t->typeclass.storagetype & TypeClass::STOR_STATIC) symstr = symbol_t->getsymbolname(); else if (symbol_t->isglobal) symstr = symbol_t->getsymbolname(); 24

27 如果变量是局部变量和临时变量, 则它们都放在栈中需要通过偏移量来访问在第三节中, 我已经叙述了栈的结构可以看到, 每一个域中, 都是以 ebp 指针为基地址进行访问对于没一个 Symbol, 都有一个偏移量属性 :offset 当前作用域的 curstartoffset 减去该变量的 offset 就可以得到该变量相对于 ebp 指针的偏移量比如现在有局部变量 t: while(1) int t; t=1; t 所在的局部作用域的 curstartoffset 为 4,t 的 offset 为 8, 那么 t 相对于 ebp 指针的偏移量就是 -4, 访问 t 的汇编代码 : mvol $1, -4(%ebp) 可以看到, 这个地方使用的是寄存器间接寻址的寻址方式对于局部变量的访问, 还有一点很重要, 那就是内层作用域访问外层变量的情况此时存在同名变量覆盖的问题, 比如下面这段代码 : Int func() int a; While (1) Int a; Int b; a=1; 当访问局部变量 a 时, 实际上访问的是内层的 a 也就是说内层的变量覆盖了外层的同名变量要做到这一点, 只需在查找变量时做一些处理即可查找变量时, 先在当前域中查找, 若当前域中查找不到, 则在 parent 域中查找, 代码如下所示 : 25

28 Symbol* Scope::searchDownUpSymbolVarMap(Scope *curscope_t, const string& symbolname_t) if (NULL == curscope_t) return NULL; Symbol *result = curscope_t->searchsymbolvarmap(symbolname_t); if (NULL!= result) return result; if (NULL == result) if ( (Scope::SCOPE_CLASS == curscope_t->scopetype) && (NULL!= curscope_t->superclass) ) result = searchdownupsymbolvarmap(curscope_t->superclass, symbolname_t); if (NULL!= result) return result; if (NULL!= curscope_t->parent) result = searchdownupsymbolvarmap(curscope_t->parent, symbolname_t); if (NULL!= result) return result; return NULL; 26

29 这里有一点需要注意 : 无论访问哪一个作用域的局部变量, 偏移量都等于访问该变量的作用域的 curstartoffset 减去该变量的 offset, 生成访问汇编代码的代码如下 : else stringstream ss; ss << scope_t->curstartoffset-symbol_t->offset << "(%ebp)"; ss >> symstr; 4.2 普通函数的调用调用普通的函数一共有五个步骤 : 参数压栈, 保护现场, 根据函数名调用函数, 清理栈中的变量, 恢复现场比如现在有一个声明如下的函数 : int func(int a, int b); 现在需要调用这个函数 : c=func(2, 4); 那么调用函数的汇编代码 : pushl -4(%ebp) pushl -8(%ebp) Movl %ebx,.bxbuff Call func Movl.bxbuff, %ebx addl $8, %esp 27

30 首先是函数参数压栈对于 C 语言来说, 若是生成 32 位的汇编, 那么参数是通过栈来传递, 并且是倒着压栈的所以这里应当先压 4 再压 2. 前面已经说过, 函数参数作为临时变量保存在栈中, 所以访问函数参数和访问临时变量是一样的, 都是寄存器间接寻址然后是保护现场保护现场就是在调用函数前将一些寄存器的值保存起来, 然后函数返回后在恢复它们的值在我们生成的汇编代码中, 只需要保存 ebx 寄存器保护现场可以将寄存器保存在栈中, 也可以保存在其他段中我选择将寄存器保存在 bss 段中因为若是将寄存器保存在栈中, 会使临时变量的偏移量发生变化故要在 bss 段中为 ebx 寄存器预留空间, 汇编代码如下所示 :.section.bss.lcomm.bxbuff, 4 然后是函数的调用, 直接 call 函数名即可最后来说一说清楚参数所占用的栈空间在压入参数前, 栈中的数据是这样的 : esp 然后压入参数后, 栈空间变成了这个样子 : 4 esp 2 28

31 最后调用函数, 然后函数返回后, 栈还是这个样子现在, 参数已经没用了, 但是还是存在于栈中, 所以需要将 esp 指针向上移动 8 个字节, 清空堆栈, 汇编如下 : addl $8, %esp 生成函数调用的汇编的代码 : int bytesize=0; if (code_t->t2 == ItmCode::OPR_ARGLIST) bytesize = Asm::genPushArgu(code_t->v2, false, scope_t, ""); addtotextsectionlist("\tmovl %ebx,.bxbuff\n"); string a = "\tcall " + ((Scope *)(code_t->v1))->getscopename() + "\n"; addtotextsectionlist(a); if (code_t->t2 == ItmCode::OPR_ARGLIST) string a; stringstream ss; string b; ss << bytesize; ss >> b; a = "\taddl $" + b + ", %esp\n"; addtotextsectionlist(a); addtotextsectionlist("\tmovl.bxbuff, %ebx\n"); 29

32 五. 成员变量与成员函数的使用以及多态的实现本节主要叙述如何使用成员变量与成员函数, 以及如何使用多态在最开始, 我要首先叙述一下为一个类的实例申请空间后, 如何分配空间比如说有这样的一个类 : class A int a; int b; int func1() int func2() 现在有一个类 A 的实例 : class A t=new A(); 为 t 分配空间后, 首先在最前面放的是成员变量 a 和 b, 然后放 func1 和 func2 的地址空间分布如下所示 : a b... func1 func2 30

33 这里需要注意的是, 为了实现多态, 同一继承链上的所有的类的成员函数的初始偏移量都要一样所以, 在一个类中定义一个成员变量后, 它的所有子类的成员变量的总大小都要增加, 代码如下 : void Scope::scopeIncSuperTotalByte(Scope *scope_t, int inc_t) if (scope_t) if (scope_t->superclass) scope_t->superclass->totalbytesize+=inc_t; Scope::scopeIncSuperTotalByte(scope_t->superClass, inc_t); 5.1 成员变量的使用要使用成员变量, 首先要找到成员变量成员变量的查找和普通变量的查找不太一样成员变量的查找首先是在本作用域里找, 本作用域里找不到再到 super 作用域 ( 即父类的作用域 ) 中找, 不需要去在上层作用域中找, 代码如下 : Symbol* Scope::resolveSymbolMemVar(Scope* classscope_t, const string &symbolname_t) if (NULL == classscope_t ) return NULL; Symbol *result = classscope_t->searchsymbolvarmap(symbolname_t); if (NULL!= result) return result; else 31

34 if ( (Scope::SCOPE_CLASS == classscope_t->scopetype) && (NULL!= classscope_t->superclass) ) result = resolvesymbolmemvar(classscope_t->superclass, symbolname_t); if (NULL!= result) return result; return NULL; 找到成员变量后, 就可以得到它的偏移量, 然后就可以对他进行访问成员变量的偏移量是相对于类的实例的指针来说的这样以来又要分两种情况 : 1. 在成员函数里访问成员变量, 此时 this 指针作为参数压进了堆栈中首先要将 this 指针赋给 ecx 寄存器 2. 以 a.b 的形式访问成员变量, 类的实例的指针以局部变量的形式存放在栈中 ( 即变量 a), 所以需要把变量 a 移到 ecx 寄存器无论如何, 现在类的实例的指针都已经移动到了 ecx 寄存器中, 那么就可以根据偏移量来访问成员变量了, 比如说 : a.b=5; 现在 b 的偏移量是 4, 那么生成的汇编为 : movl $5, 4(%ecx) 和局部变量一样都是采用的寄存器间接寻址, 只不过寄存器从 ebx 变成了 ecx 而已生成汇编代码的代码为 : 32

35 addtotextsectionlist("\tmovl 8(%ebp), %ecx\n"); stringstream ss; ss << symbol_t->getoffset() << "(%ecx)" ; ss >> symstr; 5.2 成员函数的调用以及多态的实现成员函数的调用与普通函数的调用是一样的, 都是分为五个步骤, 但是注意, 函数调用时要将 this 指针压栈而函数调用时并不是直接通过函数的名字来直接调用, 而是通过成员函数的偏移量来间接的调用正确计算成员函数的偏移量是实现多态的关键下面我将着重讲述如何计算偏移量定义一个成员函数时, 首先在父类中查找有无同名的成员函数, 若有, 则子类的成员函数的偏移量等于父类的成员函数的偏移量若没有, 则子类的成员函数的偏移量要在总偏移量的基础上加 4. 这样, 就保证了同一继承连上的同名成员函数的偏移量相同偏移量相同, 但是里面存放的函数地址不同, 这样就实现了多态计算成员函数偏移量的代码如下 ; Scope *tmpvirfunc=scope::s_curscope->resolvememfunbyname(tmpsco pe->getscopename()); if (tmpvirfunc) tmpscope->setfuncoffest(tmpvirfunc->getfuncoffset()); tmpscope->classname = Scope::s_curScope->getScopeName(); else tmpscope->setfuncoffest(scope::s_curscope->gettotalfuncby tesize()); tmpscope->classname = Scope::s_curScope->getScopeName(); Scope::s_curScope->incTotalFuncByteSize(4); 33

36 例如, 现在需要调用成员函数 : a.func() 已知 func 的偏移量为 4, 而 a 的地址已经移动到了 ecx 中, 那么就可以间接调用 : call *4(%ebx) 生成间接调用汇编的代码 : stringstream ss; string b; ss << offset; ss >> b; a = "\tcall *" + b + "(%ecx)\n"; 34

37 六. 生成汇编代码由中间代码生成汇编代码大部分是照着葫芦画瓢, 没什么好说的我这里只说两条语句, 一条是 new 语句, 一条是如 return 语句 6.1new 语句生成汇编 New 语句用于为对象申请空间, 例如 : Class A a = new A(); 它需要做的工作有 : 为对象申请空间, 然后将成员函数的地址按偏移量移动到相应的内存位置内存的申请可以直接调用 C 标准库中的 malloc 函数, 比如下面这个类 : Class A int a; int b; int func(); 假设需要申请 12 字节的空间那么汇编代码 : pushl $12 call malloc addl $4, %esp 现在, 申请的内存的首地址放在了 eax 寄存器中, 然后就可以根据偏移量将成员函数的地址移动到相应的位置 : movl $A_func, %eax 35

38 生成对应汇编代码的代码为 : Scope *tmpscope = (Scope *)(code_t->v1); string a; stringstream ss; string b; ss << tmpscope->totalbytesize+tmpscope->totalfuncbytesize; ss >> b; a = "\tpushl $" + b + "\n"; addtotextsectionlist(a); addtotextsectionlist("\tcall malloc\n"); addtotextsectionlist("\taddl $4, %esp\n"); for (int i=0; i < tmpscope->totalfuncbytesize; i+=4) Scope *tmpmemfunc = tmpscope->resolvememfunbyoffset(i); if (tmpmemfunc) string a; ss.clear(); string b; ss << i+tmpscope->totalbytesize; ss >> b; a = "\tmovl $" + tmpmemfunc->classname + "_" + tmpmemfunc->getscopename() + ", " + b + "(%eax) \n"; addtotextsectionlist(a); 36

39 6.2return 语句生成汇编 Return 语句只需做两件事 : 恢复 esp 和 ebp 寄存器, 然后返回但是, 由于 return 语句可能在内层作用域出现, 所以有可能会回复多次否则 ret 时会找不到 ip 地址生成汇编的代码为 : while ((scope_t->scopetype!= Scope::SCOPE_GLOBALFUNC) && (scope_t->scopetype!= Scope::SCOPE_GLOBALFUNCCHAN) && (scope_t->scopetype!= Scope::SCOPE_CLASSFUNC)) Asm::genFuncEnd(scope_t); scope_t = scope_t->parent; string tmpreg =Asm::genReg(((Reg *)(code_t->v3))->regindex, TypeClass::SF_INT); string a = "\tmovl " + tmpreg + ", %eax\n"; addtotextsectionlist(a); addtotextsectionlist("\tret\n"); 37

40 七. 生成可执行程序生成汇编代码后, 还需要使用 gas 汇编器进行汇编, 然后用 ld 链接最终生成可执行程序由于生成的是 32 位的汇编, 而操作系统是 64 位, 故需要加一些参数, 命令如下 : as o out.o out.s ld -melf_i386 --dynamic-linker /lib/ld-linux.so.2 out.o -lc 38

41 八. 实验感想在这次实验中, 我感觉收获还是很多的, 首先我学会了如何去做一个编译器, 这在以前是不可想象的其次, 整个代码的工程量有一万五千多行代码, 这对于我来说也是一次很好的锻炼再者, 在这次实验中, 我第一次使用了 git 来进行多人协作这也是我第一次和其他人一起写代码, 不过, 我认为最重要的收获是对编程语言的结构和多态有了更深刻的了解, 毕竟自己亲手做了一个, 这对我编程水平的提高有很大的帮助这次实验也有一些不足, 我认为首先符号表设计的有些不合理, 应该将 Scope 也当做 Symbol 来处理, 这样后面的工作可以简化不少其次就是没有进行代码优化 39

OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数

OOP with Java Yuanbin Wu cs@ecnu OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数复习类的复用组合 (composition): has-a 关系 class MyType { public int i; public double d; public char c; public void set(double