编译实验(三)目标代码生成

最新推荐文章于 2022-04-05 12:08:12 发布
最新推荐文章于 2022-04-05 12:08:12 发布
阅读量9k 收藏 63
点赞数 4
分类专栏： 算法 编译原理 文章标签： 编译 目标代码生成 C 寄存器分配
原创，想转就转
本文链接：https://blog.csdn.net/superSmart_Dong/article/details/79187150
版权

通过词法分析，语法分析，语义分析，最后产生了四元式。而代码生成则是通过四元式来完成。我们先从简单开始做起。

编译实验项目下载链接：http://download.csdn.net/download/supersmart_dong/10224159

例如四元式(j,0,0,7)这样的，代码生成只需要一个goto语句；(j=,A,B,7)代码生成为:

CMP A,B

JE .....     

目标代码如果是汇编语言的话，则代码生成对汇编要有一定了解。

指令码

意义

条件

JZ, JE

结果为0或相等则转

Z=1，(A) = (B)

JNZ, JNE

结果不为0或不相等则转

Z=0，(A)≠(B)

JNL, JGE

大于等于转

(S∨O)=0，(A)≥(B)

JL, JNGE

小于转

(S∨O)=1，(A)<(B)

JG, JNLE

大于转

(S∨O∨Z)=0，(A)>(B)

JMP

无条件转移


CMP 为比较，实际上是两个变量相减只影响标志位。

所以当(J<,A,B,7)这样的只需要一个比较语句和一个跳转语句就行。跳转到哪？当然是跳转到对应四元式所对应的代码了，我们需要引进基本块的概念，块也就是一堆顺序执行的语句序列。首先要就四元式进行划分基本块。

(1)程序第一个四元式为基本块入口

(2)跳转四元式的下一个四元式为基本块入口

(3)跳转语句要跳转到的四元式，该四元式为基本块入口

最后，相邻两个基本块入口之间的四元式构成一个基本块(其中包含前者入口，不包含后者入口)。跳转语句的跳转位置也就是基本块的名字。

首先第一步，设置基本块路口，我们四元式需要一个属性来标记是否为某基本块入口(0为否，1为是)，按照上面的三步骤，遍历四元式判断是不是第一个四元式，是不是跳转语句的四元式，是的话相应四元式属性置为1就可以。

第二步就是初始化基本块集合。遍历四元式将四元式加入基本块，直到下一个入口四元式为止，再把基本块加到集合中。

做完这些，所有跳转语句就可以完成了，跳转目的地也就是四元式对应的基本块名称。


接下来完成加减乘除的四元式代码生成。假如有ax，bx，dx寄存器可用

像(+,A,B,T1) (:=,T1,0,A)对应汇编代码应该是:

MOV  AX，A

ADD   AX,B

MOV  C,AX 

假如B的值存在了bx寄存器中：

MOV  AX，A

ADD   AX,BX

MOV  C,AX 

首先定义寄存器的数据结构，起码要有name(寄存器名称)，Rvalue(寄存器存放的值)，例如上面的代码，AX寄存器最后存放了T1和C的值。 

struct registers
{
	string	name;
	vector<string> Rvalue;
	registers(string n){ name = n; }
	registers(){};
	void clearPush(string n)
	{
		Rvalue.clear();
		Rvalue.push_back(n);
	}
	bool isinReg(string n)
	{
		bool flag = false;
		for (int i = 0; i < Rvalue.size(); i++)
		{
			if (Rvalue[i] == n)
				flag = true;
		}
		return flag;
	}
};
vector<registers> regs = { registers("AX"), registers("BX"), registers("DX") };
registers M("M");
registers findreg(string arg,int &index)
{
	//如果找到原本有的
	for (int i = 0; i < regs.size(); i++)
	{
		if (regs[i].isinReg(arg))
		{
			index = i;
			return regs[i];
		}
	}
	//没有则返回空寄存器
	for (int i = 0; i < regs.size(); i++)
	{
		if (regs[i].Rvalue.size()==0)
		{
			index = i;
			return regs[i];
		}
	}

	return NULL;
}
bool isExistRvalue(string arg)
{
	for (int i = 0; i < regs.size(); i++)
	{		
			if (regs[i].isinReg(arg))
				return true;		
	}
	return false;
}

在进行加减乘除的代码生成的时候，首先遍历所有寄存器的Rvalue查询是否存在Rvalue中，是的话返回对应寄存器。

例如进行计算A+B时，对应四元式 (+,A,B,T)，如果A和B分别在ax，bx寄存器中，对应代码：

ADD ax，bx

如果A在寄存器ax中b不在寄存器，则：

ADD ax，B

如果A在不在寄存器b在寄存器bx，则：

ADD bx，A

A和B都不在寄存器中时，返回空寄存器(假如是AX)：

mov  ax，A

add ax ,B

目标代码生成参考代码：

#include <string>
#include <vector>
#include "register.h"
//定义基本块的数据结构，定义代码表的基本结构，找到四元式的入口，划分基本块，遍历基本块进行代码生成（首先完成根据四元式地址找到基本块，完成操作符代码表），精化代码表用到寄存器分配
static int nameNum;
struct basicBlock
{
	string name;
	vector<GenStruct> gens;	
	vector <string> codes;
	basicBlock()
	{
		string str;
		int2str(nameNum,str);
		name = "L" + str;
		nameNum++;
	}
	void add(GenStruct g)
	{
		gens.push_back(g);
	}
};
class codeTable
{
private:
	vector<basicBlock> block; //基本块
	void initblock();  //初始化基本块
	int findblocknameByGen(int index);  //根据四元式地址找到基本块
	string findblocknameByGen(string index){
		int i = stoi(index);
		i=findblocknameByGen(i);
		if (i >= block.size()) return "End";
		return block[i].name;		
	}
	vector<string> createcode(GenStruct);
	void initblockcodes();
	bool stringisinGen(string,int);  //判断string 是否在index后四元式中存在
public:	
	vector<basicBlock> getBasicBlock(){ return block; }
	codeTable(){ initblock(); initblockcodes(); }
	void clearNotUse(GenStruct);
	void printcodes();
};
void codeTable::initblock()
{
	for (int i = 0; i < genStructs.size()-1; i++)
	{
		if (i == 0) {   //程序第一条为入口
			changeOut_port(0); 
		}
		if (genStructs[i].code <= 58 && genStructs[i].code >= 52) //跳转语句
		{
			changeOut_port(genStructs[i].result);//跳转到的语句为入口语句
			changeOut_port(i+1); //跳转语句的下一行,为入口语句
		}
	}
	for (int i = 0; i < genStructs.size() ; ) //把入口语句加入到基本块
	{
		basicBlock bl;
		bl.add(genStructs[i]);
		i++;
		for (; i < genStructs.size(); i++)
		{
			if (genStructs[i].out_port == 1)
			{
				block.push_back(bl);
				break;
			}
			else 
				bl.add(genStructs[i]);
		}
		if (i==genStructs.size())
			block.push_back(bl);
	}
}
int codeTable::findblocknameByGen(int index)
{
	for (int i = 0; i < block.size(); i++) //i为block索引
	{
		for (int j = 0; j < block[i].gens.size(); j++)
		{
			if (block[i].gens[j].label == index)
			{
				return i;
			}
		}
	}
	return -1;
}
void codeTable::initblockcodes()
{
	for (int blockindex = 0; blockindex < block.size(); blockindex++)
	{
		for (int i = 0; i < block[blockindex].gens.size(); i++)
		{
			block[blockindex].codes = merge(block[blockindex].codes, createcode(block[blockindex].gens[i]));
		}
	}
}
void codeTable::printcodes()
{
	for (int blockindex = 0; blockindex < block.size(); blockindex++)
	{
		cout << block[blockindex].name << ":\n";
		for (int i = 0; i < block[blockindex].codes.size(); i++)
		{
			cout << "      "<<block[blockindex].codes[i] << endl;
		}
	}
}
vector<string> codeTable::createcode(GenStruct gen)
{
	vector<string> codes;
	int code = gen.code;
	clearNotUse(gen);
	registers reg; int regindex,temp;
	switch (code)
	{

	case 41://op = "*";
		if (isExistRvalue(gen.addr1) && isExistRvalue(gen.addr2))
		{
			codes.push_back("MUL " + findreg(gen.addr1, regindex).name + "," + findreg(gen.addr2, temp).name);
			regs[regindex].clearPush(gen.result);
		}
		else if (isExistRvalue(gen.addr1) && !isExistRvalue(gen.addr2))
		{
			codes.push_back("MUL " + findreg(gen.addr1, regindex).name + "," + gen.addr2);
			regs[regindex].clearPush(gen.result);
		}
		else if (!isExistRvalue(gen.addr1) && isExistRvalue(gen.addr2))
		{
			codes.push_back("MUL " + findreg(gen.addr2, regindex).name + "," + gen.addr1);
			regs[regindex].clearPush(gen.result);
		}
		else{
			reg = findreg(gen.addr1, regindex);
			codes.push_back("MOV " + reg.name + "," + gen.addr1);
			codes.push_back("MUL " + reg.name + "," + gen.addr2);
			regs[regindex].clearPush(gen.result);
		}
		break;
	case 43://op = "+"; 
		
		if (isExistRvalue(gen.addr1) && isExistRvalue(gen.addr2))
		{
			codes.push_back("ADD " + findreg(gen.addr1, regindex).name + "," + findreg(gen.addr2, temp).name);
			regs[regindex].clearPush(gen.result);
		}
		else if (isExistRvalue(gen.addr1) && !isExistRvalue(gen.addr2))
		{
			codes.push_back("ADD " + findreg(gen.addr1, regindex).name + "," + gen.addr2);
			regs[regindex].clearPush(gen.result);
		}
		else if (!isExistRvalue(gen.addr1) && isExistRvalue(gen.addr2))
		{
			codes.push_back("ADD " + findreg(gen.addr2, regindex).name + "," + gen.addr1);
			regs[regindex].clearPush(gen.result);
		}
		else{
			reg = findreg(gen.addr1, regindex);
			codes.push_back("MOV " + reg.name + "," + gen.addr1);
			codes.push_back("Add " + reg.name + "," + gen.addr2);
			regs[regindex].clearPush(gen.result);
		}
		break;
	case 45://op = "-";
		codes.push_back("MOV " + findreg(gen.addr1, regindex).name + ",-" + gen.addr2);
		regs[regindex].clearPush(gen.result);
		break;
	case 48://op = "/"; 没有这个文法
		codes.push_back("DIV " + gen.addr1 + "," + gen.addr2);
		break;
	case 51://op = ":="; 
		reg = findreg(gen.addr1, regindex);
		codes.push_back("MOV " + gen.result + "," + reg.name);
		regs[regindex].Rvalue.push_back(gen.result);
		break;
	case 52://op = "j";
		codes.push_back("GOTO " + findblocknameByGen(gen.result));
		break;
	case 53://op = "j<"; 
		codes.push_back("CMP " + gen.addr1 + "," + gen.addr2);
		codes.push_back("JL " + findblocknameByGen(gen.result));
		break;
	case 54://op = "j<=";
		codes.push_back("CMP " + gen.addr1 + "," + gen.addr2);
		codes.push_back("JLE " + findblocknameByGen(gen.result));
		break;
	case 55://op = "j<>";
		codes.push_back("CMP " + gen.addr1 + "," + gen.addr2);
		codes.push_back("JNE " + findblocknameByGen(gen.result));
		break;
	case 56://op = "j="; 
		codes.push_back("CMP " + gen.addr1 + "," + gen.addr2);
		codes.push_back("JE " + findblocknameByGen(gen.result));
		break;
	case 57://op = "j>";
		codes.push_back("CMP " + gen.addr1 + "," + gen.addr2);
		codes.push_back("JG " + findblocknameByGen(gen.result));
		break;
	case 58://op = "j>=";
		codes.push_back("CMP " + gen.addr1 + "," + gen.addr2);
		codes.push_back("JGE " + findblocknameByGen(gen.result));
		break;
	default:
		break;
	}
	return codes;
}
bool codeTable::stringisinGen(string str,int index)
{
	for (int i = genStructs.size() - 1; i >= index; i--)   //因为先删除后操作，所以要把iindex是加进去
	{
		if (genStructs[i].addr1 == str || genStructs[i].addr2 == str)
			return true;
	}
	return false;
}
//遍历所有基本块，把非待用的寄存器里值给删了,把基本块里的Rvalue
void codeTable::clearNotUse(GenStruct gen)//运行到四元式的值
{
	int index = gen.label;
	//遍历所有寄存器的Rvalue 看看后没有在index之后的四元式出现
	for (int i = 0; i < regs.size(); i++)
	{
		for (int j = 0; j < regs[i].Rvalue.size(); j++)
		{
			if (!stringisinGen(regs[i].Rvalue[j], index))
			{
				//删除
				regs[i].Rvalue.erase(regs[i].Rvalue.begin() + j);
			}
		}
	}
}

到此为止，差不多就结束了。不过有个缺陷，就是计算一旦多起来寄存器可能就不够用了，所以在每次生成代码前还要把寄存器里非待用的给删了。何为非待用？例如：

1：  T1 ：=A+B

2：   C :=T1+A

当执行完第一句时此时T1 和A是待用的因为之后的运算用到了他们，B是非待用的因为之后的运算没用到B。

实现非待用判断不难，首先从尾至当前，遍历四元式看看第二元素，第三元素是否与之相等。

实现非待用的删除，遍历每个寄存的RValue中的值，判断该值是否非待用，是则删除。

superSmart_Dong
关注
  • 4
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
编译原理课程设计——目标代码生成器
09-13
学生在学习《编译原理》课程设计中，结合各章节的构造编译程序的基本理论，总共用一周的时间完成课程设计。要求用C或C++语言描述及上机调试，实现五个题目中任意一个，是学生将理论与实际应用结合其，起来，受到软件设计等开发过程的全面训练，从而提高学生软件开发的能力。 能完成指定寄存器个数的情况下降一中间代码程序段翻译成会变语言目标代码（汇编指令应包括加、减、乘、除），要求指令条数最少的情况下，尽量使用寄存器，尽量少访问内存，这样才能做到运行效率高。
目标代码生成 四元式
05-19
实验4.2-目标代码生成-四元式
编译原理实验代码（四则表达式编译及生成汇编代码）
11-28
这是编译原理的实验，关于四则表达式的编译（词法、语法、语义分析，目标代码生成）。里面有实验指导书以及注释详细的源代码。详细请看博客： http://blog.csdn.net/touch_2011/article/details/7019163
编译原理实验之四元式的生成源代码（c语言）
06-16
编译原理实验实验之四元式的生成的源代码，基于C语言
BIT-MiniCC——negen(lab8目标代码生成)
weixin_43877853的博客
03-02 3071
终于来到了最后一步——目标代码生成 本次的实验目标是将生成的中间代码四元式翻译成x86汇编语言 原理其实就是根据不同的四元式对应不同的语句输出为汇编代码即可 根据要求是只需要满足3个测试用例即可，再多只需要继续添加翻译语句就行 一、 1. 由于本次实验提供的测试用例的输入输出函数，Mars_PrintInt，Mars_PrintStr，Mars_GetInt在x86中并未定义。所以需要通过借用对应的c语言函数，又由于x86中对应的printf和scanf的调用处理较为特殊，所以在此处对于这一类函
湖南大学编译原理实验六：代码生成器
Moyu-42的博客
01-10 1393
由于这个版本并不完善，所以对应的代码仅供参考。对于某些较为复杂的样例：涉及到参数传递的函数调用是没有办法正确运行的。（因为在这个代码的语义分析部分，将数组元素作为了ID来处理，这就比较麻烦了。） 链接 同样的，我也是抄的。上面的链接给出了原本的代码。但是存在的问题除了上面所讲的，还有无法正确处理数组元素。在我这个版本修复了这个问题。至于什么时候把他改成一个可以完美运行的Compiler，再说吧。 代码链接：编译原理实验六 实验六代码生成器 （一）学习经典的代码生成器（2小时） 一、实验目的 学习已有.
《编译原理》画 DAG 图与求优化后的 4 元式代码- 例题解析
热门推荐
肖朋伟
06-23 2万+
《编译原理》画 DAG 图与求优化后的 4 元式代码- 例题解析
编译原理－－代码生成
x13262608581的博客
04-05 4132
编译原理－－代码生成
肥 工 大学编译原理 高分课程设计（四元式生成，python实现GUI）
一个苦逼研究僧的博客
01-28 1438
  这次课设在前面实验的基础上差不多从里到外的重写了一遍。前前后后课余时间弄了快一个月。大多数时间花在设计数据结构和debug上。   链接见文末 运行界面展示 举个文法栗子 H->S S->void main ( ) { L } S->Q L->L ; Q L->Q Q->if ( B ) { L } Q->if ( B ) { L } else { L } Q->while ( B ) { L } Q->do { L } while ( B )
编译原理完整学习笔记（八）：目标代码生成
Gene_I must wait for the sunrise
08-19 4712
文章目录目标代码生成一、目标代码生成概述1.1 任务1.2 输入1.3 输出二、抽象计算机模型三、代码生成3.1 代码生成原则3.2 待用信息和活跃信息3.2.1 概念解释3.2.2 符号表示3.3 变量地址、寄存器描述3.3.1 目的3.3.2 概念3.4 代码生成算法3.4.1 算法描述3.4.2 算法举例四、DAG的目标代码 目标代码生成 一、目标代码生成概述 1.1 任务 将分析、翻译、优化后的中间代码变换成目标代码 1.2 输入 源程序的中间表示，以及符号表中的信息 类型检查均已完成 1.3
赋值语句翻译c语言实现（四元式）
06-02
此程序使用算符优先法的语义分析方法实现了将赋值语句翻译为四元式的功能。这种仅将{=,+,-,*,/}当做运算符，而将括号当做深度的变种算符优先法，很好控制，很容易就能翻译赋值语句。该程序是linux平台下的，若要在Windows下，只需将头文件unistd.h改为io.h
编译原理目标代码
01-18
编译原理最后一次作业，在词法分析、语法分析、语义分析、中间代码基础上实现目标代码。压缩包里有源代码，实验报告和技术文档。
编译原理（将简单程序翻译成四元式）
12-02
文法规则： 1.—>program id 2.—> { 语句 [ 语句 ] } 3.—>||| || 4.—> id [ , id ] ； 5.—> integer | float 6.—> input id [ , id ] ； 7.—> output [ , ] ； 8.—> id = ； 9.—> if { else } 10.—> while 11.—> [ +|－ ] 12.—> [ *|/ ] 13.—> id | con | deci | ( ) 14.—> [ and | or ] 15.—> 16.—> < | | >= | == |
中间代码生成实验报告.doc
03-29
中间代码生成实验报告 本实验报告的主要目的是在实验二的基础上，增加中间代码生成部分，使程序能够对实验二中的识别出的赋值语句、if 语句和 while 语句进行语义分析，生成四元式中间代码。 编译原理是计算机科学...
编译原理实验报告-目标代码的优化
06-11
东北大学编译原理实验报告，用编译语言实现目标代码的优化，有详细的代码
重大-编译原理-目标代码生成程序的设计与实现.zip
最新发布
06-01
重大-编译原理-目标代码生成程序的设计与实现.zip
最新计算机编译原理实验生成四元式序列教学提纲
07-02
* 编译原理的主要步骤包括词法分析、语法分析、语义分析、中间代码生成、优化和目标代码生成等。 知识点2: 语法分析 * 语法分析是编译原理的重要组成部分，旨在将源代码解析成抽象语法树（Abstract Syntax Tree，...
编译原理中间代码生成器实现C++
10-30
编译原理中间代码生成器实现C++编译原理中间代码生成器实现C++
编译原理之目标代码生成
勿忘初心的博客
12-18 9239
所有的源码：https://github.com/yanguojun123/Compile 先上代码： （其余后面完善） #pragma once #include<iostream> #include<string> #include <fstream> #include <sstream> #include<Windows.h...
编译原理 中间代码生成实验
07-14
中间代码生成是编译器的一个重要步骤，它将源代码转换成更低级别的中间代码，这些中间代码可以被进一步优化和转换成目标机器代码。下面是一个简单的中间代码生成实验： 1. 定义语法分析树的节点结构，包括节点类型、值、子节点等信息。 2. 实现语法分析器，将源代码转换成语法分析树。 3. 实现中间代码的生成器，遍历语法分析树并生成中间代码。 4. 实现一个简单的目标代码生成器，将中间代码转换成目标机器代码。 5. 测试，编写一些简单的源代码并进行编译，观察中间代码和目标代码是否符合预期。 在实现中间代码生成器时，需要考虑如何表示中间代码的指令、如何管理符号表、如何处理控制流语句等问题。同时，还需要考虑如何进行代码优化，例如常量折叠、死代码消除等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值