• 编译一日一练（DIY系列之汇编输出）

    【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】

            代码地址：https://github.com/feixiaoxing/DIYCompiler/blob/master/day10/Parse.jj 

            前面的几章，我们陆续讨论了词法分析、语法树、复杂语法树、语义分析、中间代码输出这些环节，今天终于到了汇编代码这个大结局了。很多人都认为编译器，就是把源代码编译成二进制文件。这其实是一个误会。大部分编译器的工作就是把source code变成汇编代码而已，剩下来的可以由专门的工具将这些汇编代码转成二进制文件，比如binutils等等。当然，如果生成的代码不适用于cpu来执行，而是用于虚拟机vm解析的，类似于jvm这样，其实也是可以的。

            汇编的输出也涉及到几个方面。第一，不同os支持的汇编格式不一样，比如windows支持的汇编文件和linux支持的文件格式就是不一样的；第二，除了输出函数代码之外，全局变量的输出，第三方函数的引用这些都是要考虑进去的；第三，函数的压栈、出栈部分，这个需要依据不同的cpu进行不同的处理；第四，函数入参、返回值寄存器的选择一般是固定的，生成汇编的时候要注意下；第五，通用寄存器的选择，有的比较简单，比如一些脚本语言只有3~4个寄存器，完全谈不上寄存器选择，有的比如arm、mips、powerpc这些，多达32个寄存器，中间选择的空间很大；第六，汇编的优化，比如有两个相连的指令 store [tmp1], ax; mov ax, [tmp1]，那这两条指令就可以删除；第七，指令的选择。

            上面虽然说了这么多，回到今天四则运算的汇编输出，其实就没有这么难了。我们可以选用x86的ax和bx寄存器，处理的其实就是除法指令。但是有一点大家需要注意下，中间代码和汇编代码之间并非是一一对应的关系，很多时候，需要用好几条汇编指令才能对应一条中间代码，这些都是常有的事情。当然，如果后端接入的是llvm，这些就不需要我们自己考虑了。

            鉴于之前已经输出了中间代码，这里直接看汇编是如何输出的即可，

    1. 	// tranlsater inter-mediate code, with input is inter-mediate code, and output is assmeble code
    2. 	public static String translate_single_code(String input)
    3. 	{
    4. 		String assemble = "";
    5.  
    6. 		String[] sub = input.split(" ");
    7. 		if(sub[2].charAt(0) >= '0' && sub[2].charAt(0) <= '9')
    8. 		{
    9. 			assemble += "mov ax," + sub[2] + "\n";
    10. 		}
    11. 		else
    12. 		{
    13. 			assemble += "load ax,[" + sub[2] + "]\n";
    14. 		}
    15.  
    16. 		assemble += "mov bx," + sub[4] + "\n";
    17. 		assemble += "div ax, bx\n";
    18. 		assemble += "store [" + sub[1] + "],ax\n";
    19.  
    20. 		return assemble;
    21. 	}

             这是翻译单条中间代码的函数。翻译的方法不难，主要是判断第一个除数是来自于整数，还是来自于临时变量。如果是整数，那么直接用mov将数据拷贝到ax即可。要不然，就将数据从mem加载到ax。剩下的动作就是常规操作，将另外一个数据拷贝到bx，开始除法运算，一般cpu除法的结果保存在ax，这个时候只需要将ax用store命令保存到mem变量就可以了。注意，这里的ax、bx来自于cpu空间，而临时变量只能是mem空间里面。

    1. 	public static String translate_code(String input)
    2. 	{
    3. 		String[] sub;
    4. 		String str = "";
    5. 	
    6. 		if(input == "")
    7. 		{
    8. 			return "";
    9. 		}
    10.  
    11. 		sub = input.split("\n");
    12. 		for(int i = 0; i < sub.length; i++)
    13. 		{
    14. 			str += translate_single_code(sub[i]);
    15. 		}
    16.  
    17. 		return str;
    18. 	}	
    19. }

            有了单条中间代码的翻译，多条中间代码的翻译就很好理解了。只需要用换行符号\n分割之后，拿出来一条一条翻译即可。

            等到这一切都做好之后，可以看一下翻译的效果如何，

    1. C:\Users\feixiaoxing\Desktop\DIYCompiler\day10>java Parse 6/3
    2.  
    3. tmp1
    4.      6
    5.      3
    6.  
    7. mov ax,6
    8. mov bx,3
    9. div ax, bx
    10. store [tmp1], ax
    11.  
    12.  
    13. C:\Users\feixiaoxing\Desktop\DIYCompiler\day10>java Parse 6/3/2
    14.  
    15. tmp2
    16.      tmp1
    17.           6
    18.           3
    19.      2
    20.  
    21. mov ax,6
    22. mov bx,3
    23. div ax, bx
    24. store [tmp1], ax
    25. load ax,[tmp1]
    26. mov bx,2
    27. div ax, bx
    28. store [tmp2], ax
    29.  
    30.  
    31. C:\Users\feixiaoxing\Desktop\DIYCompiler\day10>java Parse 6/3/2/1
    32.  
    33. tmp3
    34.      tmp2
    35.           tmp1
    36.                6
    37.                3
    38.           2
    39.      1
    40.  
    41. mov ax,6
    42. mov bx,3
    43. div ax, bx
    44. store [tmp1], ax
    45. load ax,[tmp1]
    46. mov bx,2
    47. div ax, bx
    48. store [tmp2], ax
    49. load ax,[tmp2]
    50. mov bx,1
    51. div ax, bx
    52. store [tmp3], ax

            整体来看，输出的效果尚可接受，不过汇编还有很大的优化空间，比如store和load语句其实是可以删除的。优化的意思是说，原来的汇编语言也是对的，但是某些语句删除了之后，效果可以更好。最后，为了便于大家学习，这里在此贴出完成的jj文件供大家参考，

    1. options {
    2.     STATIC = false;
    3. }
    4.  
    5. PARSER_BEGIN(Parse)
    6. import java.io.*;
    7.  
    8. class node
    9. {
    10. 	public node left;
    11. 	public node right;
    12. 	public String node_type;
    13. 	public String node_name;
    14. 	public int depth;
    15. 	
    16. 	node() {this.left = this.right = null;}
    17. 	public void set_left_node(node left) { this.left = left;}
    18. 	public node get_left_node() { return this.left;}
    19. 	
    20. 	public void set_right_node(node right) { this.right = right;}
    21. 	public node get_right_node() {return this.right;}
    22. 	
    23. 	public void set_node_type(String node_type) {this.node_type = node_type;}
    24. 	public String get_node_type() {return this.node_type;}
    25. 	
    26. 	public void set_node_name(String node_name) {this.node_name = node_name;}
    27. 	public String get_node_name() {return this.node_name;}
    28.  
    29. 	public void set_depth(int depth) {this.depth = depth;}
    30. 	public int get_depth() {return this.depth;}
    31. 	public int calculate_depth() { // node depth should be calculated before print it, so just calculate root node
    32.  
    33. 		int left_depth = 0;
    34. 		int right_depth = 0;
    35. 		int final_depth = 0;
    36. 		if(get_left_node() == null && get_right_node() == null) {
    37. 			set_depth(1);
    38. 			return 1;
    39. 		}
    40. 		
    41. 		if(null != get_left_node()) {
    42. 			left_depth = get_left_node().calculate_depth();
    43. 		}
    44.  
    45. 		if(null != get_right_node()){
    46. 			right_depth = get_right_node().calculate_depth();
    47. 		}
    48. 		
    49. 		final_depth = (left_depth > right_depth) ? (left_depth+1) :(right_depth +1);
    50. 		set_depth(final_depth);
    51. 		return final_depth;
    52. 	}
    53. 	
    54. 	public void print_node(int start_depth, int start_point) // add print node function
    55. 	{
    56. 		int i = 0;
    57. 		
    58. 		for(i =0; i < (start_point - start_depth*5); i++){
    59. 			System.out.print(" ");
    60. 		}
    61. 		
    62. 		if(get_node_type() != "value_node")
    63. 		{
    64. 			System.out.println(get_node_name());
    65. 		}
    66. 		else
    67. 		{
    68. 			System.out.println(((value_node)this).get_value());
    69. 		}
    70.  
    71. 		if(get_left_node() != null) get_left_node().print_node(start_depth -1, start_point);
    72. 		if(get_right_node() != null) get_right_node().print_node(start_depth -1, start_point);
    73. 	}
    74. }
    75.  
    76. class value_node extends node
    77. {
    78. 	public int value;
    79. 	
    80. 	value_node() { set_node_type("value_node");}
    81. 	public int get_value() { return this.value;}
    82. 	public void set_value(int value) {this.value = value;}
    83. }
    84.  
    85. class div_node extends node
    86. {
    87. 	div_node() { set_node_type("/");}
    88. 	
    89. 	public int get_value() {
    90. 		int left = 0, right = 0;
    91. 		
    92. 		// get left node
    93. 		if(get_left_node().get_node_type() == "/")
    94. 		{
    95. 			left = ((div_node)get_left_node()).get_value();
    96. 		}
    97. 		else
    98. 		{
    99. 			left = ((value_node)get_left_node()).get_value();
    100. 		}
    101.  
    102. 		// get right node
    103. 		if(get_right_node() == null)
    104. 		{
    105. 			return left;
    106. 		}
    107. 		else
    108. 		{
    109. 			right = ((value_node)get_right_node()).get_value();
    110. 			return left/right;
    111. 		}
    112. 	}
    113.  
    114. 	// add semantic check
    115. 	public int check_value() {
    116. 	
    117. 		if(get_right_node() != null)
    118. 		{
    119. 			if( 0 == ((value_node)get_right_node()).get_value())
    120. 			{
    121. 				System.out.println("Div by Zero");
    122. 				return -1;
    123. 			}
    124. 		}
    125. 		
    126. 		if(get_left_node().get_node_type() == "/")
    127. 		{
    128. 			return ((div_node)(get_left_node())).check_value();
    129. 		}
    130.  
    131. 		return 1;
    132. 	}
    133. 	
    134. 	// generate inter-mediate code
    135. 	public String generate_intermediate_code()
    136. 	{
    137. 		int value;
    138. 		String str = "";
    139. 		
    140. 		if(get_left_node().get_node_type() == "/")
    141. 		{
    142. 			str = ((div_node)get_left_node()).generate_intermediate_code();
    143. 		}
    144. 		
    145. 		if(null == get_right_node())
    146. 		{
    147. 			return "";
    148. 		}
    149.  
    150. 		set_node_name("tmp" + Integer.toString(Parse.allocate_index()));
    151. 		if(get_left_node().get_node_type() == "/")
    152. 		{
    153. 			str += "div " + get_node_name() + " " + get_left_node().get_node_name() + " / " + Integer.toString(((value_node)get_right_node()).get_value()) + "\n";
    154. 		}
    155. 		else
    156. 		{
    157. 			str += "div " + get_node_name() + " " + Integer.toString(((value_node)get_left_node()).get_value()) + " / " + Integer.toString(((value_node)get_right_node()).get_value()) + "\n";
    158. 		}
    159.  
    160. 		return str;
    161. 	}
    162. }
    163.  
    164. public class Parse {
    165.  
    166.     public static int index = 0;
    167.  
    168.     public static void main(String[] args) {
    169.         for (String arg : args) {
    170.             try {
    171. 				div_node div = evaluate(arg);
    172. 				String str = div.generate_intermediate_code();
    173.  
    174. 				System.out.println("");
    175. 				div.calculate_depth();
    176. 				div.print_node(div.get_depth(), div.get_depth()*5);
    177.  
    178. 				System.out.println("");
    179. 				System.out.println(translate_code(str));
    180.  
    181.                 //System.out.println(div.check_value());
    182.             } catch (ParseException ex) {
    183.                 System.err.println(ex.getMessage());
    184.             }
    185.         }
    186.     }
    187.  
    188.     public static div_node evaluate(String src) throws ParseException {
    189.         Reader reader = new StringReader(src);
    190.         return  new Parse(reader).expr();
    191.     }
    192. 	
    193. 	// important index
    194. 	public static int allocate_index()
    195. 	{
    196. 		index += 1;
    197. 		return index;
    198. 	}
    199.  
    200. 	// tranlsater inter-mediate code, with input is inter-mediate code, and output is assmeble code
    201. 	public static String translate_single_code(String input)
    202. 	{
    203. 		String assemble = "";
    204.  
    205. 		String[] sub = input.split(" ");
    206. 		if(sub[2].charAt(0) >= '0' && sub[2].charAt(0) <= '9')
    207. 		{
    208. 			assemble += "mov ax," + sub[2] + "\n";
    209. 		}
    210. 		else
    211. 		{
    212. 			assemble += "load ax,[" + sub[2] + "]\n";
    213. 		}
    214.  
    215. 		assemble += "mov bx," + sub[4] + "\n";
    216. 		assemble += "div ax, bx\n";
    217. 		assemble += "store [" + sub[1] + "],ax\n";
    218.  
    219. 		return assemble;
    220. 	}
    221.  
    222. 	public static String translate_code(String input)
    223. 	{
    224. 		String[] sub;
    225. 		String str = "";
    226. 	
    227. 		if(input == "")
    228. 		{
    229. 			return "";
    230. 		}
    231.  
    232. 		sub = input.split("\n");
    233. 		for(int i = 0; i < sub.length; i++)
    234. 		{
    235. 			str += translate_single_code(sub[i]);
    236. 		}
    237.  
    238. 		return str;
    239. 	}	
    240. }
    241. PARSER_END(Parse)
    242.  
    243. SKIP: { <[" ", "\t", "\r", "\n"]> }
    244. TOKEN: {
    245.     <INTEGER: (["0"-"9"])+>
    246. }
    247.  
    248. div_node expr() throws NumberFormatException :
    249. {
    250.     Token a ;
    251.     Token b ;
    252.     div_node div;
    253. }
    254. {
    255. 	a = <INTEGER> 
    256. 	{ 
    257. 		value_node node_a = new value_node();
    258. 		node_a.set_value(Integer.parseInt( a.image ));
    259. 		
    260. 		div = new div_node();
    261. 		div.set_left_node(node_a);
    262. 		
    263. 	}
    264. 	
    265. 	(
    266. 	"/" b = <INTEGER>
    267. 	{
    268. 		value_node node_b = new value_node();
    269. 		node_b.set_value(Integer.parseInt( b.image ));
    270.  
    271. 		// important code about node adding
    272. 		if(div.get_right_node() == null)
    273. 		{
    274. 			div.set_right_node(node_b);
    275. 		}
    276. 		else
    277. 		{
    278. 			div_node prev = div;
    279. 			div = new div_node();
    280. 			
    281. 			div.set_left_node(prev);
    282. 			div.set_right_node(node_b);
    283. 		}
    284. 	}
    285. 	)*
    286. 	
    287. 	<EOF>
    288. 	{ return div ; }
    289. }

  • 相关阅读:
    C++笔记之临时变量与临时对象与匿名对象
    java单向循环链表（含约瑟夫问题代码展示）
    注入攻击
    郑州什么企业会使用灵活用工平台？
    网络安全（4）
    用springboot改写传智健康项目问题
    springmvc总结
    Prometheus+Grafana环境搭建（window）
    【Python百日进阶-WEB开发-冲進Flask】Day182 - Flask蓝图与模板继承
    虚拟机配置完NAT模式之后可以和主机ping通但是ping 百度显示：网络不可达
  • 原文地址：https://blog.csdn.net/feixiaoxing/article/details/127681638