自制编译器：后端代码生成（二）

最新推荐文章于 2024-01-13 11:52:08 发布
最新推荐文章于 2024-01-13 11:52:08 发布
阅读量2.6k 收藏 2
点赞数
分类专栏： 自制Compiler
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ROger__wonG/article/details/9101143
版权
本文介绍了自制编译器中后端代码生成的过程，涉及stmts和stmt的不同类型及其对应的生成式。内容涵盖continue、break、变量声明、类初始化、设置值等语句的生成，以及ids类型的处理，包括局部变量、对象成员变量、数组元素的赋值。同时，提到了CodeGenHelper的JMP方法和ids的genCode逻辑。
摘要由CSDN通过智能技术生成

（8）stmts

stmts逻辑上代表一个语句块或一组语句块，对应的生成式和在节点中使用的type如下：

stmts --> NUL|            type-->0


                  stmt stmts|        type-->1


                  if(expr) { stmts} stmts|   type-->2


                  if(expr) {stmts} else {stmts}  stmts|       type-->3


                  while(expr) { stmts}     stmts|    type-->4

接下来给出生成后端代码的代码：

public void genCode() {
		if(type==1)
		{
			st.genCode();
			stmts1.genCode();
		}
		else if(type==2)
		{
			condition.genCode();
			Code code=new Code(0x18);
			BackendClassManager.tFunc.codes.add(code);
			stmts1.genCode();
			code.Operands.add(String.valueOf(BackendClassManager.tFunc.codes.size()));
			stmts3.genCode();
		}
		else if(type==3)
		{
			condition.genCode();
			Code code=new Code(0x18);
			code.Opcode=0x18;
			BackendClassManager.tFunc.codes.add(code);
			stmts1.genCode();
			Code code1=new Code(0x01);
			code1.Operands.add(String.valueOf(0));
			BackendClassManager.tFunc.codes.add(code1);
			Code code2=new Code(0x18);
			BackendClassManager.tFunc.codes.add(code2);
			code.Operands.add(String.valueOf(BackendClassManager.tFunc.codes.size()));
			stmts2.genCode();
			code2.Operands.add(String.valueOf(BackendClassManager.tFunc.codes.size()));
			stmts3.genCode();
		}
		else if(type==4)
		{
			ArrayList<Code> albreak=new ArrayList<Code>();
			ArrayList<Code> alcontinue=new ArrayList<Code>();
			BackendClassManager.loopbreak.add(albreak);
			BackendClassManager.loopcontinue.add(alcontinue);//循环入口，首先判断expr
			int pos=BackendClassManager.tFunc.codes.size();
			condition.genCode();
			//跳转指令
			Code code=new Code(0x18);
			BackendClassManager.tFunc.codes.add(code);
			//循环体
			stmts1.genCode();
			
		//	code.Operands.add(String.valueOf(end));//表达式回填
			
			Code code1=new Code(0x01);
			code1.Operands.add(String.valueOf(0));
			BackendClassManager.tFunc.codes.add(code1);//压入0
			
			Code code2=new Code(0x18);
			code2.Operands.add(String.valueOf(pos));
			BackendClassManager.tFunc.codes.add(code2);//跳转到循环入口
			
			int end=BackendClassManager.tFunc.codes.size();
			code.Operands.add(String.valueOf(end));//表达式回填
			
			for(Code c:albreak)
			{
				c.Operands.add(String.valueOf(end));
			}
			for(Code c:alcontinue)
			{
			   c.Operands.add(String.valueOf(pos));
			}
			BackendClassManager.loopbreak.pop();
			BackendClassManager.loopcontinue.pop();
			stmts3.genCode();
		}
		
	}
对于type=0，没必要生成任何代码；对于type=1，生成stmt的代码然后递归再生成stmts的代码；对于type=2，首先生成条件expr的代码，在这段代码执行过后，会将结果放在堆栈顶，然后加入code(0x18)进行跳转，但此刻的跳转地址还不能确定，因此先要生成stmts1的代码，之后回填跳转地址，再生成stmts3的代码；对于type=3，和type=2类似，但要在stmts1代码之后加入无条件跳转指令，跳转到else块后面，无条件跳转的方法是首先压入0，再使用0x18也就是ifz进行跳转;对于type=4要稍微复杂些，首先要计算循环开始的地址（包括判断expr），然后生成循环体代码，得到循环结束地址，再回填循环判断的相关代码，除此之外，还要回填此循环体内出现的所有break和continue语句的地址。


(9)stmt

首先给出语句stmt的生成式：

 stmt -->   continue;|   type=0
 
                break;|    type=1


                var-declare;|   type=2


               class-init;|    type=3


               setvalue;|   type=4


               expr;|       type=5


接下来给出代码：

public void genCode() {
		ArrayList<Code> al=BackendClassManager.tFunc.codes;
		if(type==0)
		{
			CodeGenHelper.JMP(al, 0);
			BackendClassManager.loopcontinue.peek().add(al.get(al.size()-1));
		}
		if(type==1)
		{
			CodeGenHelper.JMP(al, 0);
			BackendClassManager.loopbreak.peek().add(al.get(al.size()-1));
		}
		if(type==5)
		{
			ep.genCode();
		}
		if(type==2)
		{
			vc.genCode();
		}
		if(type==3)
		{
			ci.genCode();
		}
		if(type==4)
		{
			sv.genCode();
		}
	}
stmt代码比较简单，对于break和continue，只需要加入一个跳转语句，然后把此跳转语句加入到相应的列表里（因为循环是嵌套的，所以使用堆栈来表示这一关系），由外层循环体进行地址回填即可，使用了CodeGenHelper的JMP方法作为辅助函数；对于其它类型则调用其相应节点的genCode方法。

另外给出CodeGenHelper的JMP方法，封装了压入0和ifz两条指令：

public static void JMP(ArrayList<Code> al,int pos)
	{
		Code code1=new Code(0x01);
		code1.Operands.add(String.valueOf(0));
		BackendClassManager.tFunc.codes.add(code1);//压入0
		
		Code code2=new Code(0x18);
		code2.Operands.add(String.valueOf(pos));
		BackendClassManager.tFunc.codes.add(code2);//跳转
	}

（10）classinit

递推式：class-init --> ids = new 


            type ( args )| type[expr]
        type:     0            1              

代码：

public void genCode() {
		ArrayList<Code> al=BackendClassManager.tFunc.codes;
		ag.genCode();
		if(type==0)
		{
			Code code=new Code(0x1C);
			code.Operands.add(tp.toString());
			al.add(code);
		}
		else
		{
			Code code=new Code(0x1D);
			code.Operands.add(tp.toString());
			al.add(code);
		}
		if(is.type==1)
		{
			int slot=CodeGenHelper.SearchByName(is.ID.toString());
			Code code=new Code(0x05);
			code.Operands.add(String.valueOf(slot));
			al.add(code);
		}
		if(is.type==2)
		{
			if(is.getLastIDS().type!=3)
			{
			CodeGenHelper.PutObjectToStack(al, is);
			CodeGenHelper.ChangeStackTopEle(al);
			
			CodeGenHelper.CodePutField(al, is.getLastID().toString());
			}
			else
			{
				int value=CodeGenHelper.StoreToLocalTable(al);
				CodeGenHelper.PutObjectToStack(al, is);
				CodeGenHelper.CodeGetField(al, is.getLastID().toString());
				int array=CodeGenHelper.StoreToLocalTable(al);
				is.getLastIDS().EXPR.genCode();
				CodeGenHelper.LoadToStack(al, array);

				CodeGenHelper.LoadToStack(al, value);
				Code code=new Code(0x26);
				al.add(code);
			}
		}
		if(is.type==3)
		{
			int slot=CodeGenHelper.StoreToLocalTable(al);
			is.EXPR.genCode();
			CodeGenHelper.LoadToStackByName(al, is.ID.toString());
			CodeGenHelper.LoadToStack(al, slot);
			Code code=new Code(0x26);
			al.add(code);
		}
	}
首先ag.genCode()把所有参数压栈，然后根据类别判断是初始化对象还是数组来使用0x1C或者0x1D指令并把类型作为操作数，当此条指令执行完之后，堆栈顶此时放着返回的对象或数组的句柄，接下来的任务是将该句柄赋值给ids。

接着判断ids的类型，ids的推导式如下：

ids-> 
*       id|       type 1
          id.ids|      type  2
         id[expr]     type 3
          this|       type=4

如果type=1，则说明是一个局部变量，从nameSlot中找到该局部变量在局部变量表里的位置（相关操作封装到了CodeGenHelper的searchByName中），赋值给这个槽即可。

如果type=2，说明是某个对象的成员变量，则需要先把这个对象压入堆栈，再通过putfield指令给此对象赋值，若是某个对象的成员变量中的某个元素（即该成员变量是个数组），则需要使用给数组赋值的指令。

如果type=3，说明给数组某个元素赋值，需要先把下标计算出来，然后通过相应指令给数组赋值。

其中的很多操作都封装在了CodeGenHelper中。


（11）vardeclare

递推式：

var-declare --> type args|type[] args

代码：

public void genCode() {
		ArrayList<Code> al=BackendClassManager.tFunc.codes;
		ArrayList<ids> idlist=ags.getidsList();
		for(ids id:idlist)
		{
		BackendClassManager.nameSlot.put(id.getLastID().toString(), BackendClassManager.nameSlot.size());
		}
		
		
	}
可以看到，在变量声明时并没有生成任何实际代码，只是在局部变量表中给其开辟了一个存储位置而已。


（12）setvalue

setvalue--> ids = expr   

public void genCode() {
		ArrayList<Code> al=BackendClassManager.tFunc.codes;
	      ep.genCode();
	  	if(is.type==1)
		{
			int slot=CodeGenHelper.SearchByName(is.ID.toString());
			Code code=new Code(0x05);
			code.Operands.add(String.valueOf(slot));
			al.add(code);
		}
		if(is.type==2)
		{
			if(is.getLastIDS().type!=3)
			{
			CodeGenHelper.PutObjectToStack(al, is);
			CodeGenHelper.ChangeStackTopEle(al);
			
			CodeGenHelper.CodePutField(al, is.getLastID().toString());
			}
			else
			{
				int value=CodeGenHelper.StoreToLocalTable(al);
				CodeGenHelper.PutObjectToStack(al, is);
				CodeGenHelper.CodeGetField(al, is.getLastID().toString());
				int array=CodeGenHelper.StoreToLocalTable(al);
				is.getLastIDS().EXPR.genCode();
				CodeGenHelper.LoadToStack(al, array);

				CodeGenHelper.LoadToStack(al, value);
				Code code=new Code(0x26);
				al.add(code);
			}
		}
		if(is.type==3)
		{
			int slot=CodeGenHelper.StoreToLocalTable(al);
			is.EXPR.genCode();
			CodeGenHelper.LoadToStackByName(al, is.ID.toString());
			CodeGenHelper.LoadToStack(al, slot);
			Code code=new Code(0x26);
			al.add(code);
		}
		
	}
setvalue和classinit的代码几乎一样，唯一的区别是classinit中需要调用new和newarray指令得到需要给ids赋的值，而setvalue则是通过计算expr来得到，即使用ep.genCode();


(13)ids

ids的genCode逻辑是指将此ids的值放到堆栈顶，此值或许是个int、double，也可能是个对象的句柄。

递推式：

ids-> 
	 *       id|       type 1
          id.ids|      type  2
         id[expr]     type 3
          this|       type=4

代码： 

public void genCode() {
		ArrayList<Code> al=BackendClassManager.tFunc.codes;
		if(type==1)
		{
			Integer slot=BackendClassManager.nameSlot.get(ID.toString());
			if(slot!=null)
			{
			Code code=new Code(0x03);
			code.Operands.add(String.valueOf(slot));
			al.add(code);
			}
			else
			{
				//error
			}
		}
		if(type==2)
		{
			int slot=BackendClassManager.nameSlot.get(ID.toString());
			Code code=new Code(0x03);
			code.Operands.add(String.valueOf(slot));
			al.add(code);
			IDS.genCode2nd();
		}
		if(type==3)
		{
			EXPR.genCode();//压入expr值
			int slot=BackendClassManager.nameSlot.get(ID.toString());
			Code code=new Code(0x03);
			code.Operands.add(String.valueOf(slot));
			al.add(code);//压入array
			
			code=new Code(0x04);
			al.add(code);//读取数组元素
			
			
			
		}
		if(type==4)
		{
			int slot=BackendClassManager.nameSlot.get("this");
			Code code=new Code(0x01);
			code.Operands.add(String.valueOf(slot));
		}
	}
	
	
	public void genCode2nd() {
		ArrayList<Code> al=BackendClassManager.tFunc.codes;
		if(type==1)
		{
			Code code=new Code(0x20);
			code.Operands.add(ID.toString());
			al.add(code);
		}
		if(type==2)
		{
			Code code=new Code(0x20);
			code.Operands.add(ID.toString());
			al.add(code);
			IDS.genCode2nd();
		}
		if(type==3)
		{
			EXPR.genCode();//压入expr值
			Code code=new Code(0x20);
			code.Operands.add(ID.toString());
			al.add(code);//压入数组
			code=new Code(0x04);
			al.add(code);//读取数组元素
		}
		if(type==4)
		{
		 //error
		}
	}

由于ids的结构不对称，所以不能使用递归的方式来获得其值。举例：id.id，第一个id的处理方式是通过局部变量表中拿到其句柄，第二个id的处理方式要通过getfield来拿到其值。因此这两种处理方式对应的是genCode和genCode2nd。

只有当第一次调用的时候（也就是其它节点调用）调用genCode，ids节点调用均调用genCode2nd。


（未完待续）




ROger__Wong
关注
专栏目录
基于LLVM的编译原理简明教程: 写一个自己的编译器​
程序员光剑
09-29 1万+
LLVM简介进入21世纪，新的编程语言如雨后春笋一样不停地冒出来。需求当然是重要的驱动力量，但是在其中起了重要作用的就是工具链的改善。2000年，UIUC的Chris Lattner主持开...
编译器设计-代码生成
吴建明wujianming_110117
06-24 720
编译器设计-代码生成 Compiler Design - Code Generation 代码生成可以看作是编译的最后阶段。通过后代码生成，优化过程可以应用到代码上，但这可以看作是代码生成阶段本身的一部分。编译器生成的代码是一些低级编程语言（例如汇编语言）的目标代码。我们已经看到，用高级语言编写的源代码被转换为低级语言，从而生成低级目标代码，该目标代码应至少具有以下属性： 它应该具有源代码的确切含义。 它应该在CPU使用和内存管理方面是高效的。 现在我们将看到如何将中间代码转换为目标对象代码（在本例中是汇编
自制编译器：后端代码生成（三）
锐之锋芒
06-16 3406
（14）expr /*                         Type * expr -->  (expr)           0                 ids|             1               number|           2               literal|           3              func-
自制编译器：后端代码生成
西红柿炒土豆
10-06 1633
所谓的编译器后端的作用就是将语法树翻译成目标机器码。所谓目标机器码，考虑到直接翻译成具体平台（如X86，ARM等）过于复杂，因此先设计一个虚拟机，并翻译成这个虚拟机的机器码。 对于虚拟机以及其指令格式可参考这篇文章http://blog.csdn.net/roger__wong/article/details/8947720，如何去尝试实现这个虚拟机是在我的另外一个系列的博客里进行论述。
第十一章 编译器：代码生成
A446376407的博客
11-10 677
项目介绍 本章的任务是将jack语言翻译成vm语言。上一章我们已经完成了编译器的tokenizen部分，即获取字元的部分，而且上一章的compilationEngine部分输出了一个xml文档。但是先别的得意，因为这两章的complilationEngine差别很大，基本上无法重复使用上一章的代码，建议重写。否则你会很头大。 https://github.com/Metaphor-pump/e
代码生成过程-编译最后一步
liixnhai的博客
04-06 809
编译的最后一步，也就是生成目标代码，则必须是跟特定 CPU 架构相关的。 这就是编译器的后端。不过，后端不只是简单地生成目标代码，它还要完成与机器相关的一些优化工作，确保生成的目标代码的性能最高。 看看编译器是如何通过指令选择、寄存器分配、指令排序和基于机器代码的优化等步骤，完成整个代码生成的任务的 编译器后端的任务：生成针对不同架构的目标代码。 生成针对不同 CPU 的目标代码 int foo(int a, int b){ return a + b + 10; } ...
自制编译器：后端代码生成（一）
锐之锋芒
06-12 5745
后端早就已经弄的差不多了，因为学校论文的事情耽搁的比较久，一直到现在才发博客。 所谓的编译器后端的作用就是将语法树翻译成目标机器码。所谓目标机器码，考虑到直接翻译成具体平台（如X86，ARM等）过于复杂，因此先设计一个虚拟机，并翻译成这个虚拟机的机器码。 对于虚拟机以及其指令格式可参考这篇文章http://blog.csdn.net/roger__wong/article/details/89
fbLua:由 flex、bison 和 llvm 生成的 Lua 编译器
06-13
编译器可以预先分析和优化代码，生成更接近机器码的字节码，这可能导致更快的启动时间和运行速度。此外，编译器还可以支持静态类型检查，提高代码质量和安全性。 ### 5. fbLua-dev：开发资源与进阶学习 "fbLua-dev...
ece466-compilers:具有flex + bison +自定义AST前端和针对x86-64的自制后端的简单ISO C编译器
04-06
请注意，令牌定义基于Bison生成的parser.tab.h，因此必须在构建词法分析器之前生成解析器。 独立的词法分析器将打印可读的标记化输出。 要独立构建/使用： cd 1-lexer make ./lex OR gcc -E code.c | ./lex 您还...
编译器 前端示例代码java版
11-19
`java11.y`文件则很可能包含了Bison（或者Yacc）生成的语法分析器的源代码，这部分是编译器前端的核心。它的任务是解析词法分析器产生的标记流，根据预先定义的语言语法规则（通常以BNF或EBNF形式表示）构建抽象语法...
自己动手写编译器、链接器源代码
05-26
自己动手写编译器、链接器源代码 自己动手写编译器、链接器源代码 自己动手写编译器、链接器源代码
自己动手写编译器链接器_源码
10-31
自己动手写编译器链接器_源码。免费来源于网络，免费上传之！
一个小型编译器源码
07-30
一个小型编译器源码
汇编代码生成和编译器的后端
最新发布
JJ-Li的博客
01-13 766
算式识别程序，编译器后端，汇编代码生成
中间代码生成及编译器后端概述
阿伟のBlog
08-15 2179
中间代码生成及编译器后端概述 中间代码的生成 经过了词法分析,语法分析,语义分析之后就到了中间代码生成阶段 中间代码有两种形式: 三地址码 语法结构树(简称语法树),这和之前的语法分析树不同 三地址码 三地址码由类似汇编语言的指令序列组成,每个指令最多有三个操作数,所以称为三地址码 地址可以有三种形式 源程序中的名字(变量名) 常量 编译器产生的临时变量 常见的三地址指令 三地址指令的表示 四元式 三元式 间接三元式 目标代码的生成 中间代码生成之后会对其代码进行一定程度的优化,然后就进入
探讨：别人的代码&自己N天前写的代码（多线程）
三禾木
10-18 626
编程工作中： 有个痛点叫做：别人的代码&自己N天前写的代码。 痛点的症状是：一时间找不到南北，相应花费时间才能缕清具体的来龙去脉。 当前比较多的解决办法是，注释规范化。这个有督促还好，若是没有，很多时候就没有注释了。这就造成了代码不容易看懂。 是否还有别的？这里说一个使用多线程的解决办法。 多线程的特点是根据线程间通讯，来实现多个线程协同工作。 一个生活中通俗的例子就是去饭馆吃饭：点菜，做菜和上菜。分成三个线程，各自工作，是不受影响的。 以下是这三个线程的状态： 点菜：等待客人，记录客人点
后端编译与优化（JIT，即时编译器）
weixin_52383177的博客
11-05 928
Java程序最初都是通过解释器 （Interpreter）进行解释执行的，当虚拟机发现某个方法或代码块的运行特别频繁，就会把这些代码认定为“热点代码”（Hot Spot Code），为了提高热点代码的执行效率，在运行时，虚拟机将会把这些代码编译成本地机器码，并以各种手段尽可能地进行代码优化，运行时完成这个任务的后端编译器被称为即时编译器。
自制编译器：语法分析器（二）
热门推荐
锐之锋芒
05-16 1万+
这篇博文拖了好久才写完，其一是语法分析器本身的难度实在有点超出我的预料，以至于反复重构多次才完成，其二是因为弄了个xbox玩，占用了一部分的课余时间= =！。 本篇博文将分为以下几个部分来描述一下语法分析器的具体实现，理论、部分典型节点与结果。 一、语法制导翻译、LL与LL（X）语法、左递归等其它 为什么要写一个语法分析器？语法分析器的作用不仅仅是来检查词素列表中的序列是否是一个我们
自制编译器：语法分析器（一）
锐之锋芒
04-29 1万+
感觉语法分析器在编译器前端是一个较为庞大的东西，因此打算分两篇博客来描述，第一篇着重描述思想，第二篇具体论述实现。   1、语法分析器要做什么 在编写任何一个东西的的时候，都要先弄明白这个玩意儿是做什么的，接受什么输入，产生什么输出。 一个语法分析器要接受词法分析器所产生的词素作为输入，产生一个抽象语法树给中间代码生成器，然后再由中间代码生成器生成中间代码并递交给编译器后端。当然在某些理解
C语言编译器后端：目标代码生成与解析
在生成目标代码时，编译器后端会遍历这个AST，将其转化为特定机器指令。以赋值语句为例，如`p=1;`和`a[2]=7;`，编译器会生成汇编代码来移动数值并存储到变量或数组元素的地址中。这涉及到计算变量的内存地址，对于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值