Making a Compiler - 版本历史

2022年3月19日 (六) 00:42 Zhang3

2022-03-19T00:42:30Z

←上一版本		2022年3月19日 (六) 00:42的版本
第25行：		第25行：
	* 需要完全理解所需的语言。要始终制定充分的官方语言规范。		* 需要完全理解所需的语言。要始终制定充分的官方语言规范。
	* 还需要了解特定于目标的汇编过程。		* 还需要了解特定于目标的汇编过程。
	* 关于 [[Getting Started~~#Getting motivated~~\| ~~OSDev动机~~]]这篇文章的大多数注解也适用于编译器。		* 关于 [[Getting Started\|起步指南]]这篇文章的大多数注解也适用于编译器。
	* 完全实现一套语言规范将很棘手。		* 完全实现一套语言规范将很棘手。
	* 如果你想在编译代码的大小/速度优化方面与GCC竞争，则必须非常非常擅长做编译器。		* 如果你想在编译代码的大小/速度优化方面与GCC竞争，则必须非常非常擅长做编译器。
第38行：		第38行：
	* “Target目标” 是要运行编译后得到程序的地方。		* “Target目标” 是要运行编译后得到程序的地方。
	* “run-time运行时” 是目标上存在的资源 (库，进程等)集合。两台具有相同硬件的机器在运行时资源的可用性方面不同，有时则被认为是不同的目标，因此一个程序可能在一个计算机上运行，但不能在另一个计算机上运行。		* “run-time运行时” 是目标上存在的资源 (库，进程等)集合。两台具有相同硬件的机器在运行时资源的可用性方面不同，有时则被认为是不同的目标，因此一个程序可能在一个计算机上运行，但不能在另一个计算机上运行。
	* “[[Executable Formats\| 可执行文件]]” 是一种文件，其中包含目标启动程序所需的信息。它通常是直接的二进制文件，但通常结构更精细，例如包含链接和重新定位信息。		* “[[Executable Formats\|可执行文件]]” 是一种文件，其中包含目标启动程序所需的信息。它通常是直接的二进制文件，但通常结构更精细，例如包含链接和重新定位信息。
	* “link链接” 表示程序知道如何与运行时对接，并依赖运行时的某些功能。它是由 [[Linkers\| 链接器]] 创建的，并且在自主程序 (即OS内核) 中不存在。		* “link链接” 表示程序知道如何与运行时对接，并依赖运行时的某些功能。它是由 [[Linkers\|链接器]] 创建的，并且在自主程序 (即OS内核) 中不存在。

	如果主机和目标是相同的，则产品是 “原生可执行文件（native executable）”。 99%的情况下，你遇到的就是这种。		如果主机和目标是相同的，则产品是 “原生可执行文件（native executable）”。 99%的情况下，你遇到的就是这种。
第62行：		第62行：
	* 然后，'''parser解析器''' 读取令牌流并构造 '''parse tree解析树'''，这是一种树状结构，表示源代码的结构。就语言制作而言，每个源代码文件都是该语言的 “sentence 句子”，并且每个句子 (如果有效) 都遵循特定的语法。		* 然后，'''parser解析器''' 读取令牌流并构造 '''parse tree解析树'''，这是一种树状结构，表示源代码的结构。就语言制作而言，每个源代码文件都是该语言的 “sentence 句子”，并且每个句子 (如果有效) 都遵循特定的语法。
	* 接下来，'''semantic analyzer 语义分析器''' 遍历解析树，并确定该 “句子” 每个部分的特定含义。例如，如果是声明语句，则它将条目添加到符号表中，并且如果它是涉及变量的表达式，则它将符号表中已知变量的地址替换为表达式中的变量。		* 接下来，'''semantic analyzer 语义分析器''' 遍历解析树，并确定该 “句子” 每个部分的特定含义。例如，如果是声明语句，则它将条目添加到符号表中，并且如果它是涉及变量的表达式，则它将符号表中已知变量的地址替换为表达式中的变量。
	* 最后，前端生成一个 '''Intermediate Representation 中间层表达' ''，它捕获程序源代码特定的所有信息。一个好的IR可以说明源代码所表达的所有内容甚至更多，还可以捕获该语言对程序的其他要求。它可以是 '''parse tree 解析树 ''' 、 '''abstract syntax tree 抽象语法树 ''' 、 '''three address code 三地址代码 ''' 或更奇特的东西。		* 最后，前端生成一个 '''Intermediate Representation 中间层表达'''，它捕获程序源代码特定的所有信息。一个好的IR可以说明源代码所表达的所有内容甚至更多，还可以捕获该语言对程序的其他要求。它可以是 '''parse tree 解析树 ''' 、 '''abstract syntax tree 抽象语法树 ''' 、 '''three address code 三地址代码 ''' 或更奇特的东西。

	值得注意的是，这种划分纯粹是为了方便编译器开发人员。大多数类型的 '''parsers 解析器''' 可以轻松读取字符流，而不是分词令牌流，因此不需要单独的扫描器。一些非常强大的解析器类甚至可以 “在阅读完成之前” 确定语句的语义含义，因此不需要语义分析器。不过，它们可能会更难理解和使用。		值得注意的是，这种划分纯粹是为了方便编译器开发人员。大多数类型的 '''parsers 解析器''' 可以轻松读取字符流，而不是分词令牌流，因此不需要单独的扫描器。一些非常强大的解析器类甚至可以 “在阅读完成之前” 确定语句的语义含义，因此不需要语义分析器。不过，它们可能会更难理解和使用。

2022年1月25日 (二) 09:10 Zhang3

2022-01-25T09:10:03Z

←上一版本		2022年1月25日 (二) 09:10的版本
第41行：		第41行：
	* “link链接” 表示程序知道如何与运行时对接，并依赖运行时的某些功能。它是由 [[Linkers\| 链接器]] 创建的，并且在自主程序 (即OS内核) 中不存在。		* “link链接” 表示程序知道如何与运行时对接，并依赖运行时的某些功能。它是由 [[Linkers\| 链接器]] 创建的，并且在自主程序 (即OS内核) 中不存在。

	如果主机和目标是相同的，则产品是 ~~“本机可执行文件（native~~ executable）”。 99%的情况下，你遇到的就是这种。		如果主机和目标是相同的，则产品是 “原生可执行文件（native executable）”。 99%的情况下，你遇到的就是这种。
	如果编译器能够为与主机不同的目标生成可执行文件，则它是 “交叉编译器（cross-compiler）”。		如果编译器能够为与主机不同的目标生成可执行文件，则它是 “交叉编译器（cross-compiler）”。
	如果编译器能够编译出自己，那就是 “自我托管（self-hosting）”的。		如果编译器能够编译出自己，那就是 “自我托管（self-hosting）”的。
第70行：		第70行：

	=== 后端 ===		=== 后端 ===
	* ~~首先，“code~~ generator ~~代码生成器”（译者注：这里指汇编语言代码）~~ 读取中间表示，并生成出类似汇编的代码，唯一的区别是，为简单起见，它假定目标是一台具有无限数量的寄存器 (或其他资源) 的机器。		* 首先，'''code generator 代码生成器'''（译者注：这里指汇编语言代码）读取中间表示，并生成出类似汇编的代码，唯一的区别是，为简单起见，它假定目标是一台具有无限数量的寄存器 (或其他资源) 的机器。
	* 其次，'''register allocator寄存器分配器''' 通过决定何时将变量存储在寄存器或内存中来处理CPU上的可用寄存器。这部分对性能会有 ''主要'' 影响。一旦完成，类似汇编的代码就会变成真实 '''汇编'''。		* 其次，'''register allocator寄存器分配器''' 通过决定何时将变量存储在寄存器或内存中来处理CPU上的可用寄存器。这部分对性能会有 ''主要'' 影响。一旦完成，类似汇编的代码就会变成真实 '''汇编'''。
	* 然后，'''assembler 汇编器''' 读取汇编并输出 '''machine code 机器码'''。通常，代码仍然有一些未解决的引用问题（译者注：指对外部库的依赖引用），因此将机器代码放入 '''object file 对象文件 ''' 中。		* 然后，'''assembler 汇编器''' 读取汇编并输出 '''machine code 机器码'''。通常，代码仍然有一些未解决的引用问题（译者注：指对外部库的依赖引用），因此将机器代码放入 '''object file 对象文件 ''' 中。

2022年1月25日 (二) 09:06 Zhang3

2022-01-25T09:06:56Z

←上一版本		2022年1月25日 (二) 09:06的版本
第1行：		第1行：
	{{Template:In_Progress}}		{{Template:In_Progress}}

	所以你想从头开始制作自己的 [[compiler]]？		所以你想从头开始制作自己的 [[compiler\|编译器]]？

	这并不容易。有些编译器的复杂度与整个简单操作系统相当。		这并不容易。有些编译器的复杂度与整个简单操作系统相当。

	~~尽管如此，它还是一个有趣的和~~/或有教育意义的项目。以下是开始之前你应该知道的一些事情:		尽管如此，它还是一个有趣且/或有教育意义的项目。以下是开始之前你应该知道的一些事情:

	== 利弊 ==		== 利弊 ==
第12行：		第12行：
	优点:		优点:
	* 你想要的语言和目标的编译器可能根本不存在。		* 你想要的语言和目标的编译器可能根本不存在。
	* 教育目的，你可以更好地了解 [[How kernel, compiler, and C library ~~work together\|how the kernel, compiler, and the run-time libraries~~ work together\|内核、编译器和运行时库如何一起工作]]，以及实现一种语言需要什么。		* 教育目的，你可以更好地了解 [[How kernel, compiler, and C library work together\|内核、编译器和运行时库如何一起工作]]，以及实现一种语言需要什么。
	* 说到这里，你可以立即实现自己的新编程语言!有多酷啊？		* 说到这里，你可以立即实现自己的新编程语言!有多酷啊？
	* 你可以对正在编译的程序执行几乎任何操作:		* 你可以对正在编译的程序执行几乎任何操作:
第26行：		第26行：
	* 还需要了解特定于目标的汇编过程。		* 还需要了解特定于目标的汇编过程。
	* 关于 [[Getting Started#Getting motivated\| OSDev动机]]这篇文章的大多数注解也适用于编译器。		* 关于 [[Getting Started#Getting motivated\| OSDev动机]]这篇文章的大多数注解也适用于编译器。
	* ~~完全遵守语言规范将很棘手。~~		* 完全实现一套语言规范将很棘手。
	* 如果你想在编译代码的大小/~~速度优化方面与GCC竞争，则必须非常非常擅长。~~		* 如果你想在编译代码的大小/速度优化方面与GCC竞争，则必须非常非常擅长做编译器。

	== 术语 ==		== 术语 ==
第36行：		第36行：
	术语:		术语:
	* “Host主机” 是编译器本身运行的环境。		* “Host主机” 是编译器本身运行的环境。
	* “Target目标” ~~是要运行编译得到程序的地方。~~		* “Target目标” 是要运行编译后得到程序的地方。
	* “run-time运行时” ~~是目标上存在的集合资源~~ (库，进程等)。两台具有相同硬件的机器在运行时资源的可用性方面不同，有时则被认为是不同的目标，因此一个程序可能在一个计算机上运行，但不能在另一个计算机上运行。		* “run-time运行时” 是目标上存在的资源 (库，进程等)集合。两台具有相同硬件的机器在运行时资源的可用性方面不同，有时则被认为是不同的目标，因此一个程序可能在一个计算机上运行，但不能在另一个计算机上运行。
	* “[[Executable Formats\| 可执行文件]]” 是一种文件，其中包含目标启动程序所需的信息。它通常是直接的二进制文件，但通常结构更精细，例如包含链接和重新定位信息。		* “[[Executable Formats\| 可执行文件]]” 是一种文件，其中包含目标启动程序所需的信息。它通常是直接的二进制文件，但通常结构更精细，例如包含链接和重新定位信息。
	* “link链接” 表示程序知道如何与运行时对接，并依赖运行时的某些功能。它是由 [[Linkers\| 链接器]] 创建的，并且在自主程序 (即OS内核) 中不存在。		* “link链接” 表示程序知道如何与运行时对接，并依赖运行时的某些功能。它是由 [[Linkers\| 链接器]] 创建的，并且在自主程序 (即OS内核) 中不存在。
第47行：		第47行：
	== 内部 ==		== 内部 ==
	[[Image:compilers2.png\|right]]		[[Image:compilers2.png\|right]]
	编译器也有奇特的内部结构。 ~~你不必完全能复述这里描述的那个定义，但目前这是一个很好的路线图。~~ 通常，编译程序的任务分为几个单独的任务:		编译器也有奇特的内部结构。你不必完全能复述这里描述的那些定义，但目前这是一个很好的路线图。通常，编译程序的任务分为几个单独的任务:

	* ''' Front End 前端 ''' 采用某些特定语言的源代码，并输出通用的 “中间表示” (IR)。		* ''' Front End 前端 ''' 采用某些特定语言的源代码，并输出通用的 “中间表示” (IR)。
	* '''Middle End 中端 ''' (可选) 采用中间表示形式，以某种方式对其进行更改，然后将其输出回去。		* '''Middle End 中端 ''' (可选) 采用中间表示形式，以某种方式对其进行更改，然后将其输出回去。
	* ~~“Back~~ End ~~后端”~~ 获取IR并输出特定目标的可执行文件。		* '''Back End 后端''' 获取IR并输出特定目标的可执行文件。

	这种划分的想法是，通过具有不同前端和不同后端的集合，你可以将任何语言的程序编译到任何目标，因为IR对于所有目标都是相同的。		这种划分的想法是，通过具有不同前端和不同后端的集合，你可以将任何语言的程序编译到任何目标，因为IR对于所有目标都是相同的。
第60行：		第60行：
	* 对于类似C的语言，会有一个 ''' pre-processor 预处理器 ''' 从头文件中复制并粘贴代码，删除注释执行宏扩展并执行其他相对简单的任务。		* 对于类似C的语言，会有一个 ''' pre-processor 预处理器 ''' 从头文件中复制并粘贴代码，删除注释执行宏扩展并执行其他相对简单的任务。
	* 然后，一个 '''scanner 扫描器''' (或 '''tokenizer 分词器''') 将源文件分解为一系列分词令牌，代表一种语言的基本单词 (即标识符，数字和字符串常量，诸如 “if” 和 “when” 的关键字，标点符号和分号)		* 然后，一个 '''scanner 扫描器''' (或 '''tokenizer 分词器''') 将源文件分解为一系列分词令牌，代表一种语言的基本单词 (即标识符，数字和字符串常量，诸如 “if” 和 “when” 的关键字，标点符号和分号)
	* 然后，'''~~parser 解析器~~''' 读取令牌流并构造 '''parse ~~tree 解析树~~''，这是一种树状结构，表示源代码的结构。就语言制作而言，每个源代码文件都是该语言的 “sentence 句子”，并且每个句子 (如果有效) 都遵循特定的语法。		* 然后，'''parser解析器''' 读取令牌流并构造 '''parse tree解析树'''，这是一种树状结构，表示源代码的结构。就语言制作而言，每个源代码文件都是该语言的 “sentence 句子”，并且每个句子 (如果有效) 都遵循特定的语法。
	* ~~接下来，“semantic~~ analyzer ~~语义分析器”~~ 遍历解析树，并确定该 “句子” 每个部分的特定含义。例如，如果是声明语句，则它将条目添加到符号表中，并且如果它是涉及变量的表达式，则它将符号表中已知变量的地址替换为表达式中的变量。		* 接下来，'''semantic analyzer 语义分析器''' 遍历解析树，并确定该 “句子” 每个部分的特定含义。例如，如果是声明语句，则它将条目添加到符号表中，并且如果它是涉及变量的表达式，则它将符号表中已知变量的地址替换为表达式中的变量。
	* 最后，前端生成一个 '''Intermediate Representation 中间层表达' ''，它捕获程序源代码特定的所有信息。一个好的IR可以说明源代码所表达的所有内容甚至更多，还可以捕获该语言对程序的其他要求。它可以是 '''parse tree 解析树 ''' 、 '''abstract syntax tree 抽象语法树 ''' 、 '''three address code 三地址代码 ''' 或更奇特的东西。		* 最后，前端生成一个 '''Intermediate Representation 中间层表达' ''，它捕获程序源代码特定的所有信息。一个好的IR可以说明源代码所表达的所有内容甚至更多，还可以捕获该语言对程序的其他要求。它可以是 '''parse tree 解析树 ''' 、 '''abstract syntax tree 抽象语法树 ''' 、 '''three address code 三地址代码 ''' 或更奇特的东西。

第71行：		第71行：
	=== 后端 ===		=== 后端 ===
	* 首先，“code generator 代码生成器”（译者注：这里指汇编语言代码）读取中间表示，并生成出类似汇编的代码，唯一的区别是，为简单起见，它假定目标是一台具有无限数量的寄存器 (或其他资源) 的机器。		* 首先，“code generator 代码生成器”（译者注：这里指汇编语言代码）读取中间表示，并生成出类似汇编的代码，唯一的区别是，为简单起见，它假定目标是一台具有无限数量的寄存器 (或其他资源) 的机器。
	* ~~其次，“寄存器分配器”~~ 通过决定何时将变量存储在寄存器或内存中来处理CPU上的可用寄存器。这部分对性能会有 ''主要'' 影响。一旦完成，类似汇编的代码就会变成真实 '''汇编'''。		* 其次，'''register allocator寄存器分配器''' 通过决定何时将变量存储在寄存器或内存中来处理CPU上的可用寄存器。这部分对性能会有 ''主要'' 影响。一旦完成，类似汇编的代码就会变成真实 '''汇编'''。
	* 然后，'''assembler 汇编器''' 读取汇编并输出 '''machine code 机器码'''。通常，代码仍然有一些未解决的引用问题（译者注：指对外部库的依赖引用），因此将机器代码放入 '''object file 对象文件 ''' 中。		* 然后，'''assembler 汇编器''' 读取汇编并输出 '''machine code 机器码'''。通常，代码仍然有一些未解决的引用问题（译者注：指对外部库的依赖引用），因此将机器代码放入 '''object file 对象文件 ''' 中。
	* 接下来，'''链接器''' 通过将对象文件与库链接并替换指向库内正在引用的资源的指针来满足对象文件中每个未解析的引用。链接器还提供必要的信息，以便在动态链接时定位相关库，或者在静态链接时，特定库的一些或全部可能嵌入到对象文件中。链接器有时被认为是与后端甚至编译器分开的，但事实是，特定链接器的操作特定于它链接的目标 (或目标族)，所以我将其包括在编译器后端类别中。		* 接下来，'''链接器''' 通过将对象文件与库链接并替换指向库内正在引用的资源的指针来满足对象文件中每个未解析的引用。链接器还提供必要的信息，以便在动态链接时定位相关库，或者在静态链接时，特定库的一些或全部可能嵌入到对象文件中。链接器有时被认为是与后端甚至编译器分开的，但事实是，特定链接器的操作特定于它链接的目标 (或目标族)，所以我将其包括在编译器后端类别中。

	* 最后，后端通过添加目标程序加载机制所必需的元数据，将解析了所有引用的目标文件转换为可执行文件，以达到能识别程序，加载它，在必要时动态链接它并运行它。		* 最后，后端将解析所有引用,通过添加目标程序加载机制所必需的元数据，将目标文件转换为可执行文件，以达到能识别程序，加载它，在必要时动态链接它并运行它。


	~~很快，我将讨论如何实际编写这些内容。~~		后面很快，我将讨论如何实际编写这些内容。（译者注：然而并没有:-p）

2022年1月25日 (二) 08:50 Zhang3

2022-01-25T08:50:08Z

显示更改

Zhang3：创建页面，内容为“{{Template:In_Progress}} So you want to make your own compiler, from scratch? That won't be easy. Some compilers are comparable in complexity to entire simple operating systems. Still, it can be a fun and/or educational project. Here are some things you should know before you get started: ==Pros and Cons== Why write a compiler instead of using an existing one? Pros: * A compiler for the language you want and the target you want might simply does not ex…”

2022-01-25T08:48:59Z

创建页面，内容为“{{Template:In_Progress}} So you want to make your own compiler, from scratch? That won't be easy. Some compilers are comparable in complexity to entire simple operating systems. Still, it can be a fun and/or educational project. Here are some things you should know before you get started: ==Pros and Cons== Why write a compiler instead of using an existing one? Pros: * A compiler for the language you want and the target you want might simply does not ex…”

新页面

{{Template:In_Progress}}

So you want to make your own [[compiler]], from scratch?

That won't be easy. Some compilers are comparable in complexity to entire simple operating systems.

Still, it can be a fun and/or educational project. Here are some things you should know before you get started:

==Pros and Cons==
Why write a compiler instead of using an existing one?

Pros:
* A compiler for the language you want and the target you want might simply does not exist.
* Educational, you get a better idea of [[How kernel, compiler, and C library work together|how the kernel, compiler, and the run-time libraries work together]], and what it takes to implement a language.
* Speaking of, you can implement your own new programming language, right then and there! How cool is that?
* You can do just about anything with the program being compiled:
** Add debugging data in your favorite format
** Add profiling aids
** Re-write and re-arrange parts of the program
** Optimize for something specific
** Throw it out and replace it with another program
* The compiled programs would fit your machine or OS like a glove, even if it's a new OS you're developing.

Cons:
* Complete understanding of the language required. Always keep the official language spec at hand.
* Understanding of assembly specific to your target is also required.
* Most of the notes on [[Getting Started#Getting motivated|OSDev motivation]] apply to compilers as well.
* It will be tricky to fully comply with the language spec.
* You would have to be really, really good at this if you wish to compete with GCC in terms of size/speed optimization of the compiled code.

==Terminology==
Well, if you're still up to it, let's now look at how compilers work:

[[Image:compilers1.png]]

Terminology:
* The "Host" is the environment where the compiler itself runs.
* The "Target" is where the compiled program is meant to run.
* The "run-time" is a set resources (libraries, processes, etc) that exist on the Target. Two machines with identical hardware that differ in availability of run-time resources are sometimes thought of as different targets, as a program might run on one but not the other.
* The "[[Executable Formats|executable]]" is a file containing information necessary for the Target to launch the program. It can be a flat binary, but is usually more elaborate, containing for example linking and re-location information.
* The "link" signifies that the program knows how to interface with the run-time, and relies on the run-time for some of it's functionality. It is created by the [[Linkers|linker]], and does not exist in free-standing programs (i.e. OS kernel).

If the host and the target are the same the product is a "native executable". This is what you see 99% of the time.
If the compiler is capable of producing an executable for a target different from the host, it's a "cross-compiler".
If the compiler is capable of compiling itself, it's "self-hosting".

==Internals==
[[Image:compilers2.png|right]]
Compilers also have a peculiar internal structure. You do not have to replicate the one described here exactly, but it's a good road map for now. Generally, the task of compiling a program is subdivided into several individual tasks:

* The '''Front End''' takes the source code for some specific language, and outputs a universal "intermediate representation" (IR).
* The '''Middle End''' (optional) takes the intermediate representation, changes it in some way, and outputs it back.
* The '''Back End''' takes the IR and outputs an executable for a specific target.

The idea for this division is that by having a collection of different front-ends, and different back ends, you can compile a program in any language, to any target, because the IR is the same for all of them.

===Front End===

*First of all, the front end usually includes some sort of user interface, so that files and options can be accepted. Then, there are several stages of processing.
* For C-like languages, a '''pre-processor''' copies and pastes the code from header files, removes comments performs macro expansion and does other relatively simple tasks.
* Then, a '''scanner''' (or '''tokenizer''') breaks up the source file into a series of tokens, representing basic words of a language (i.e. identifiers, number and string constants, keywords like "if" and "while", punctuation marks and semicolons)
* Then, a '''parser''' reads the stream of tokens and constructs a '''parse tree''', a tree-like structure that represents the structure of the source code. In terms of language-making, each source code file is a "sentence" of the language, and every sentence, if it is valid, follows a specific syntax.
* Next, a '''semantic analyzer''' walks the parse tree and determines the specific meaning of each part of that "sentence". For instance, if a statement is a declaration, it adds an entry to a symbol table, and if it is an expression involving a variable, it substitutes an address of the known variable from the symbol table for the variable inside the expression.
* Finally, the Front End generates an '''Intermediate Representation''', which captures all the information specific to the source code of the program. A good IR says everything that the source says and more, and also captures additional requirements that the language places on the program. It can be in the form of a '''parse tree''', '''abstract syntax tree''', '''three address code''' or something more exotic.

It's worth noting that this break-up is purely for convenience of the compiler developer. Most types of '''parsers''' can easily read a stream of characters as opposed to a stream of tokens, and so do not need a separate scanner. Some very powerful classes of parsers can even determine the semantic meaning of statements ''before they're even done reading'', and so do not need a semantic analyzer. They might be more difficult to understand and work with, though.

===Middle End===
Applies a whole bunch of algorithms meant to try and make the program more efficient. I'm not really familiar with this part, so I won't go into details. Since all it does is optimization, you could omit it for simplicity.

===Back End===
* First, the '''code generator''' reads an intermediate representation, and emits assembly-like code, the only difference being that it assumes a machine with infinite number of registers (or some other resource) for simplicity.
* Second, a '''register allocator''' juggles available registers on the CPU by deciding when a variable is to be stored in a register or in memory. This part has ''major'' impact on performance. Once it's done, the assembly-like code becomes true '''assembly'''.
* Then, an '''assembler''' reads the assembly and outputs '''machine code'''. Usually, the code still has some unresolved references, so the machine code is put inside an '''object file'''.
* Next, a '''linker''' satisfies every unresolved reference in an object file by linking it against a library and substituting a pointer to the resource being referred to inside the library. The linker also supplies necessary information to locate the relevant library when linking dynamically, or, when linking statically, some or all of a particular library might be embedded in the object file. The linker is sometimes thought of as being separate from the back end or even the compiler, but the truth is, the operation of a particular linker is specific to the target (or a family of targets) that it links for, so I included it in this category.

*Finally, the back end converts the object file with all references resolved into an executable by adding meta-data necessary for the Target's program loading mechanism to recognize the program, load it, dynamically link it if necessary, and run it.

Soon, I'll go over how to actually write each of those.