前言
本章对应官方教程第4章，本章介绍如何为中间代码(LLVM IR)添加优化以及添加JIT编译器支持。
教程如下:
教你使用swift写编译器玩具（0）
教你使用swift写编译器玩具（1）
教你使用swift写编译器玩具（2）
教你使用swift写编译器玩具（3）
教你使用swift写编译器玩具（4）
教你使用swift写编译器玩具（5）
教你使用swift写编译器玩具（6）
教你使用swift写编译器玩具（7）
教你使用swift写编译器玩具（8）
仓库在这
开始
中间代码优化
我们都知道在编译的过程中有着中间代码优化这一步。我们想要中间代码能够去除无用以及重复计算的内容，所以这个时候我们需要使用中间代码优化器。
举一个例子，在没有优化之前，我们输入def test(x) (1+2+x)*(x+(1+2));获得的结果如下所示。
def test(x) (1+2+x)*(x+(1+2));
Read function definition:
define i64 @test(i64 %x) {
entry:
%add = add i64 3, %x
%add1 = add i64 %x, 3
%mul = mul i64 %add, %add1
ret i64 %mul
}
我们可以看出来其实add和add1是相同的值，完全没有必要算两次。所以经过优化之后长下面这样
def test(x) (1+2+x)*(x+(1+2));
Read function definition:
define i64 @test(i64 %x) {
entry:
%add = add i64 3, %x
%mul = mul i64 %add, %add
ret i64 %mul
}
我们可以看出出来之前的两个add被优化成了一个。
那么我们该如何添加优化呢？LLVM为我们提供了PassManager。但是有趣的是在LLVMSwift中，PassManager被deprecated了。所以我们只需要使用更简单的PassPipeliner即可。
有多简单呢？简单到只需要添加两行代码。
let passPipeliner = PassPipeliner(module: theModule)
func lexerWithDefinition(_ lexer: Lexer) {
if let p = parseDefinition() {
if let f = p.codeGen() {
//在这里调用execute()方法
passPipeliner.execute()
print("Read function definition:")
f.dump()
}
} else {
lexer.nextToken()
}
}
添加JIT支持
使用LLVMSwift中的JIT也十分简单。我们只需要在合适的地方调用即可。
首先我们定义全局变量JIT，并在main中初始化它。
var theJIT: JIT!
let targetMachine = try! TargetMachine()
theJIT = JIT(machine: targetMachine)
接着我们在lexerWithDefinition中把Module中的IR添加到JIT中。
...
f.dump()
_ = try! theJIT.addLazilyCompiledIR(theModule) { (_) -> JIT.TargetAddress in
return JIT.TargetAddress()
}
在lexerWithTopLevelExpression中把继续把Module中的IR添加到JIT中。
...
let handle = try theJIT.addEagerlyCompiledIR(theModule) { (name) -> JIT.TargetAddress in
return JIT.TargetAddress()
}
let addr = try theJIT.address(of: "__anon_expr")
typealias FnPr = @convention(c) () -> Int
let fn = unsafeBitCast(addr, to: FnPr.self)
print("Evaluated to \(fn()).")
try theJIT.removeModule(handle)
initModule()
还记得之前parseTopLevelExpr中添加的默认函数名"__anon_expr"吗？在lexerWithTopLevelExpression新增代码的意思就是把顶级表达式包在一个名为"__anon_expr"且返回值为空的函数中进行调用。
但是目前我们还只能调用一次函数，调用第二次函数时我们就找不到这个函数了。所以这个时候我们需要有一个全局的表用来记录。
var functionProtos: [String: PrototypeAST] = [:]
func getFunction(named name: String) -> Function? {
if let f = theModule.function(named: name) {
return f
} else {
let fi = functionProtos[name]
guard fi != nil else {
return nil
}
return fi?.codeGen()
}
}
接着我们需要为CallExprAST和FunctionAST替换获取函数名的方式。
//CallExprAST
let calleeF = getFunction(named: callee!)
//FunctionAST
functionProtos[proto!.name!] = proto
let theFunction = getFunction(named: proto!.name!)
guard theFunction != nil else {
return nil
}
这样我们总是可以在当前Module中获得先前定义过的函数进行调用。
最后我们还需要更新一下lexerWithDefinition方法和lexerWithExtern方法。
//lexerWithDefinition
...
f.dump()
_ = try! theJIT.addLazilyCompiledIR(theModule) { (_) -> JIT.TargetAddress in
return JIT.TargetAddress()
}
initModule()
//lexerWithExtern
...
f.dump()
functionProtos[p.name!] = p
func initModule() {
theModule = Module(name: "main")
theModule.dataLayout = targetMachine.dataLayout
}
测试
直接输入表达式。
1+20;//输入
Read top-level expression:
define i64 @__anon_expr() {
entry:
ret i64 21
}
Evaluated to 21.//输出
函数调用。
def testfunc(x y) x + y*2;//输入
Read function definition:
define i64 @testfunc(i64 %x, i64 %y) {
entry:
%mul = mul i64 %y, 2
%add = add i64 %x, %mul
ret i64 %add
}
testfunc(1, 2);//输入
Read top-level expression:
define i64 @__anon_expr() {
entry:
%call = call i64 @testfunc(i64 1, i64 2)
ret i64 %call
}
Evaluated to 5.//输出
testfunc(1, 3);//输入
Read top-level expression:
define i64 @__anon_expr() {
entry:
%call = call i64 @testfunc(i64 1, i64 3)
ret i64 %call
}
Evaluated to 7.//输出