How to Clang your Dragon 🐉: Building a Compiler with LLVM

Compilers are treated with a fearful reverence that betrays how fascinating and approachable they really are. In this talk, we'll discuss LLVM and how it works by building a real compiler for a toy language called Kaleidoscope. We'll implement many of the fundamental building blocks of compilers and see how certain Swift features make it a great compiler language.

Transcript

1. )PX
   UP
   $MBOH
   :PVS
   %SBHPO #VJMEJOH
   B
   $PNQJMFS
   XJUI
   --7. )BSMBO
   )BTLJOT
   
   ]
   
   
   !IBSMBOIBTLJOT
2. 8IBUT
   UIF
   1MBO
3. ,BMFJEPTDPQF def fact(n) if n = 0 then 1 else n * fact(n - 1);
4. "HFOEB  (P
   PWFS
   DPNQJMFS
   CBTJDT
    #VJME
   B
   MFYFS
    #VJME
   B
   QBSTFS
    (FOFSBUF
   --7.
   *3
5. $PNQJMFST
6. $PNQJMFST Input
7. $PNQJMFST -FYFS Input
8. $PNQJMFST -FYFS Token Stream Input
9. $PNQJMFST -FYFS Token Stream Input 1BSTFS
10. $PNQJMFST -FYFS Token Stream Input 1BSTFS AST
11. $PNQJMFST -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
12. 8IBU
    JT
    --7.  "
    TFU
    PG
    MJCSBSJFT
    GPS
    DPNQJMFST
     $FOUFSFE
    BSPVOE
    --7.
    *OUFSNFEJBUF
    3FQSFTFOUBUJPO
     $PEF
    HFOFSBUJPO
    GPS
    UPOT
    PG
    UBSHFUT
13. 4UFQ
    0OF -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
14. 4UFQ
    0OF -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
15. 4USVDUVSF  3FDFJWFT
    JOQVU
    BT
    B
    TUSJOH
     8BMLT
    UISPVHI
    UIF
    TUSJOH
    MPPLJOH
    GPS
    QBUUFSOT
     1BUUFSOT
    BSF
    DBMMFE
    UPLFOT
     ,FFQ
    FBUJOH
    DIBSBDUFST
    NBLJOH
    UPLFOT
    VOUJM
    ZPV
    IJU
    UIF
    FOE
16. def fact(n) if n = 0 then 1 else n * fact(n - 1); [ ] .def, .ident("fact"), .semicolon .ident("n"), .if, .ident("n"), .oper(=), .num(0), .then, .num(1), .else, .oper(*), .ident("fact"), .lParen, .ident("n"), .oper(-), .num(1), .rParen, .lParen, .rParen, .ident("n"),
18. enum Token { }
19. enum Token { } case leftParen, rightParen, def, extern, comma, semicolon, `if`, then, `else`
20. enum Token { } case leftParen, rightParen, def, extern, comma, semicolon, `if`, then, `else` case identifier(String) case number(Double)
21. enum Token { } case leftParen, rightParen, def, extern, comma, semicolon, `if`, then, `else` case identifier(String) case number(Double) case `operator`(BinaryOperator) enum BinaryOperator: Character { case plus = "+", minus = "-", times = "*", divide = "/", mod = "%", equals = "=" }
23. class Lexer {
24. class Lexer { let input: String var index: String.Index
25. class Lexer { init(input: String) { self.input = input self.index = input.startIndex } var currentChar: Character? { return index < input.endIndex ? input[index] : nil } func advanceIndex() { input.characters.formIndex(after: &index) } let input: String var index: String.Index
26. func advanceToNextToken() -> Token? {
27. func advanceToNextToken() -> Token? { while let char = currentChar, char.isSpace { advanceIndex() }
28. func advanceToNextToken() -> Token? { while let char = currentChar, char.isSpace { advanceIndex() } guard let char = currentChar else { return nil }
29. func advanceToNextToken() -> Token? { while let char = currentChar, char.isSpace { advanceIndex() } guard let char = currentChar else { return nil } let singleTokMapping: [Character: Token] = [ ",": .comma, "(": .leftParen, ")": .rightParen, ";": .semicolon, "+": .operator(.plus), "-": .operator(.minus), "*": .operator(.times), "/": .operator(.divide), "%": .operator(.mod), "=": .operator(.equals) ]
30. func advanceToNextToken() -> Token? { while let char = currentChar, char.isSpace { advanceIndex() } guard let char = currentChar else { return nil } if let tok = singleTokMapping[char] { advanceIndex() return tok } let singleTokMapping: [Character: Token] = [ ",": .comma, "(": .leftParen, ")": .rightParen, ";": .semicolon, "+": .operator(.plus), "-": .operator(.minus), "*": .operator(.times), "/": .operator(.divide), "%": .operator(.mod), "=": .operator(.equals) ]
31. if char.isAlphanumeric {
32. if char.isAlphanumeric { let str = readIdentifierOrNumber()
33. if char.isAlphanumeric { let str = readIdentifierOrNumber() if let dblVal = Double(str) { return .number(dblVal) }
34. if char.isAlphanumeric { let str = readIdentifierOrNumber() if let dblVal = Double(str) { return .number(dblVal) } switch str { case "def": return .def case "extern": return .extern case "if": return .if case "then": return .then case "else": return .else default: return .identifier(str) }
35. if char.isAlphanumeric { let str = readIdentifierOrNumber() if let dblVal = Double(str) { return .number(dblVal) } switch str { case "def": return .def case "extern": return .extern case "if": return .if case "then": return .then case "else": return .else default: return .identifier(str) } } return nil }
36. func lex() -> [Token] { var toks = [Token]() while let tok = advanceToNextToken() { toks.append(tok) } return toks } }
37. -FYFS
    ✅
38. 4UFQ
    5XP -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
39. 4UFQ
    5XP -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
40. "CTUSBDU
    4ZOUBY
    5SFF 'JMF
41. "CTUSBDU
    4ZOUBY
    5SFF &YUFSO 'JMF
42. "CTUSBDU
    4ZOUBY
    5SFF &YUFSO 'VODUJPO 'JMF
43. "CTUSBDU
    4ZOUBY
    5SFF &YUFSO 'VODUJPO &YQSFTTJPO 'JMF
44. ,BMFJEPTDPQF
    "45 extern sin(n); &YUFSOBM
    %FGJOJUJPOT struct Prototype { let name: String let params: [String] } 4XJGU
    4USVDUVSF
45. extern sin(n); &YUFSOBM
    %FGJOJUJPOT def plusOne(n) n + 1; 'VODUJPO
    %FGJOJUJPOT struct Prototype { let name: String let params: [String] } struct Definition { let prototype: Prototype let expr: Expr } 4XJGU
    4USVDUVSF ,BMFJEPTDPQF
    "45
46. extern sin(n); &YUFSOBM
    %FGJOJUJPOT def plusOne(n) n + 1; 'VODUJPO
    %FGJOJUJPOT n + 1 * foo(n * 3); &YQSFTTJPOT struct Prototype { let name: String let params: [String] } 4XJGU
    4USVDUVSF struct Definition { let prototype: Prototype let expr: Expr } indirect enum Expr { case number(Double) case variable(String) case binary(Expr, BinaryOperator, Expr) case call(String, [Expr]) case ifelse(Expr, Expr, Expr) } ,BMFJEPTDPQF
    "45
47. 4USVDUVSF  3FDFJWFT
    UPLFOT
    GSPN
    -FYFS
     3FDVSTJWF
    %FTDFOU
     1BSTFST
    SFDVSTF
    JOUP
    FBDI
    PUIFS
     FH
    %FGJOJUJPO
    VTFT
    1SPUPUZQF
    BOE
    &YQSFTTJPO
     $POTUBOUMZ
    VQEBUF
    UIF
    "CTUSBDU
    4ZOUBY
    5SFF
48. var externs = [Prototype]() var definitions = [Definition]() var expressions = [Expr]() class File {
49. var externs = [Prototype]() var definitions = [Definition]() var expressions = [Expr]() var prototypeMap = [String: Prototype]() class File { func prototype(name: String) -> Prototype? { return prototypeMap[name] }
50. var externs = [Prototype]() var definitions = [Definition]() var expressions = [Expr]() var prototypeMap = [String: Prototype]() func addExtern(_ prototype: Prototype) { externs.append(prototype) prototypeMap[prototype.name] = prototype } func addDefinition(_ definition: Definition) { definitions.append(definition) prototypeMap[definition.prototype.name] = definition.prototype } class File { func prototype(name: String) -> Prototype? { return prototypeMap[name] }
51. var externs = [Prototype]() var definitions = [Definition]() var expressions = [Expr]() var prototypeMap = [String: Prototype]() class File { func addExpression(_ expression: Expr) { expressions.append(expression) } func addExtern(_ prototype: Prototype) { externs.append(prototype) prototypeMap[prototype.name] = prototype } func addDefinition(_ definition: Definition) { definitions.append(definition) prototypeMap[definition.prototype.name] = definition.prototype } func prototype(name: String) -> Prototype? { return prototypeMap[name] } }
52. enum ParseError: Error { case unexpectedToken(Token) case unexpectedEOF } class Parser {
53. class Parser { enum ParseError: Error { case unexpectedToken(Token) case unexpectedEOF } let tokens: [Token] var index = 0 init(tokens: [Token]) { self.tokens = tokens } var currentToken: Token? { return index < tokens.count ? tokens[index] : nil } func consumeToken() { index += 1 }
54. func consume(_ token: Token) throws { guard let tok = currentToken else { throw ParseError.unexpectedEOF } guard token == tok else { throw ParseError.unexpectedToken(token) } consumeToken() }
55. func consume(_ token: Token) throws { guard let tok = currentToken else { throw ParseError.unexpectedEOF } guard token == tok else { throw ParseError.unexpectedToken(token) } consumeToken() } func parsePrototype() throws -> Prototype { let name = try parseIdentifier() let params = try parseCommaSeparatedInParens(parseIdentifier) return Prototype(name: name, params: params) }
56. func consume(_ token: Token) throws { guard let tok = currentToken else { throw ParseError.unexpectedEOF } guard token == tok else { throw ParseError.unexpectedToken(token) } consumeToken() } func parsePrototype() throws -> Prototype { let name = try parseIdentifier() let params = try parseCommaSeparatedInParens(parseIdentifier) return Prototype(name: name, params: params) } func parseExtern() throws -> Prototype { try consume(.extern) let prototype = try parsePrototype() try consume(.semicolon) return prototype }
57. func parseExpr() throws -> Expr {
58. func parseExpr() throws -> Expr { guard let token = currentToken else { throw ParseError.unexpectedEOF }
59. func parseExpr() throws -> Expr { guard let token = currentToken else { throw ParseError.unexpectedEOF } var expr: Expr switch token {
60. func parseExpr() throws -> Expr { guard let token = currentToken else { throw ParseError.unexpectedEOF } var expr: Expr case .number(let value): consumeToken() expr = .number(value) switch token {
61. func parseExpr() throws -> Expr { guard let token = currentToken else { throw ParseError.unexpectedEOF } var expr: Expr case .leftParen: // ( <expr> ) consumeToken() expr = try parseExpr() try consume(.rightParen) case .number(let value): consumeToken() expr = .number(value) switch token {
62. func parseExpr() throws -> Expr { guard let token = currentToken else { throw ParseError.unexpectedEOF } var expr: Expr case .leftParen: // ( <expr> ) consumeToken() expr = try parseExpr() try consume(.rightParen) case .number(let value): consumeToken() expr = .number(value) case .identifier(let value): consumeToken() if case .leftParen? = currentToken { let params = try parseCommaSeparatedInParens(parseExpr) expr = .call(value, params) } else { expr = .variable(value) } switch token {
63. case .identifier(let value): consumeToken() if case .leftParen? = currentToken { let params = try parseCommaSeparatedInParens(parseExpr) expr = .call(value, params) } else { expr = .variable(value) } case .if: // if <expr> then <expr> else <expr> consumeToken() let cond = try parseExpr() try consume(.then) let thenVal = try parseExpr() try consume(.else) let elseVal = try parseExpr() expr = .ifelse(cond, thenVal, elseVal)
64. case .identifier(let value): consumeToken() if case .leftParen? = currentToken { let params = try parseCommaSeparatedInParens(parseExpr) expr = .call(value, params) } else { expr = .variable(value) } case .if: // if <expr> then <expr> else <expr> consumeToken() let cond = try parseExpr() try consume(.then) let thenVal = try parseExpr() try consume(.else) let elseVal = try parseExpr() expr = .ifelse(cond, thenVal, elseVal) default: throw ParseError.unexpectedToken(token) }
65. case .if: // if <expr> then <expr> else <expr> consumeToken() let cond = try parseExpr() try consume(.then) let thenVal = try parseExpr() try consume(.else) let elseVal = try parseExpr() expr = .ifelse(cond, thenVal, elseVal) default: throw ParseError.unexpectedToken(token) } if case .operator(let op)? = currentToken { consumeToken() let rhs = try parseExpr() return .binary(expr, op, rhs) } return expr }
66. func parseDefinition() throws -> Definition { try consume(.def) let prototype = try parsePrototype() let expr = try parseExpr() try consume(.semicolon) return Definition(prototype: prototype, expr: expr) }
67. func parseFile() throws -> File { let file = File() while let tok = currentToken { switch tok { case .extern: file.addExtern(try parseExtern()) case .def: file.addDefinition(try parseDefinition()) default: let expr = try parseExpr() try consume(.semicolon) file.addExpression(expr) } } return file }
69. 4UFQ
    5ISFF -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
70. 4UFQ
    5ISFF -FYFS Token Stream AST Input 1BSTFS $PEF
    (FO
71. --7.
    *3  )JHI
    MFWFM
    "TTFNCMZ
     /P
    MPPQT
    POMZ
    HPUPT
     &YQMJDJU
    UZQFT
    FWFSZXIFSF
     %POU
    UIJOL
    BCPVU
    CJUT
     4UBUJD
    4JOHMF
    "TTJHONFOU define double @plusOne(double %n) { entry: %0 = fadd double %n, 1.000000e+00 ret double %0 } def plusOne(n) n + 1;
72. 4UBUJD
    4JOHMF
    "TTJHONFOU define double @plusOne(double %n) { entry: %0 = fadd double %n, 1.000000e+00
73. 4UBUJD
    4JOHMF
    "TTJHONFOU define double @plusOne(double %n) { entry: %0 = fadd double %n, 1.000000e+00 %1 = fmul double %0, 2.000000e+00
74. 4UBUJD
    4JOHMF
    "TTJHONFOU define double @plusOne(double %n) { entry: %0 = fadd double %n, 1.000000e+00 %1 = fmul double %0, 2.000000e+00 %2 = fdiv double %1, 3.141592e+00
75. 4UBUJD
    4JOHMF
    "TTJHONFOU define double @plusOne(double %n) { entry: %0 = fadd double %n, 1.000000e+00 %1 = fmul double %0, 2.000000e+00 %2 = fdiv double %1, 3.141592e+00 ret double %2 }
76. )PX
    EP
    XF
    VTF
    --7.
    JO
    4XJGU
77. --7.
    JT
    B
    $
    -JCSBSZ
    4XJGU
    BOE
    $
    BSFOU
    PO
    TQFBLJOH
    UFSNT
78. --7.
    $
    "1* 6OTBGF.VUBCMF1PJOUFS--7.7BMVF3FG withUnsafeMutableBufferPointer() LLVMAppendBasicBlockInContext(_:UnsafeMutablePointer<Int8> _:LLVMContextRef!)
79. 0QFO
    4PVSDF
80. class IRGenerator { let module: Module let builder: IRBuilder let file: File
81. class IRGenerator { private var parameterValues = [String: IRValue]() let module: Module let builder: IRBuilder let file: File
82. class IRGenerator { private var parameterValues = [String: IRValue]() init(file: File) { self.module = Module(name: "kaleidoscope") self.builder = IRBuilder(module: module) self.file = file } let module: Module let builder: IRBuilder let file: File
83. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function }
84. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function } let argTypes = [IRType](repeating: FloatType.double, count: prototype.params.count)
85. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function } let argTypes = [IRType](repeating: FloatType.double, count: prototype.params.count) let funcType = FunctionType(argTypes: argTypes, returnType: FloatType.double)
86. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function } let argTypes = [IRType](repeating: FloatType.double, count: prototype.params.count) let funcType = FunctionType(argTypes: argTypes, returnType: FloatType.double) let function = builder.addFunction(prototype.name, type: funcType)
87. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function } let argTypes = [IRType](repeating: FloatType.double, count: prototype.params.count) let funcType = FunctionType(argTypes: argTypes, returnType: FloatType.double) let function = builder.addFunction(prototype.name, type: funcType) for (var param, name) in zip(function.parameters, prototype.params) { param.name = name }
88. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function } let argTypes = [IRType](repeating: FloatType.double, count: prototype.params.count) let funcType = FunctionType(argTypes: argTypes, returnType: FloatType.double) let function = builder.addFunction(prototype.name, type: funcType) for (var param, name) in zip(function.parameters, prototype.params) { param.name = name } return function }
89. @discardableResult func emitPrototype(_ prototype: Prototype) -> Function { if let function = module.function(named: prototype.name) { return function } let argTypes = [IRType](repeating: FloatType.double, count: prototype.params.count) let funcType = FunctionType(argTypes: argTypes, returnType: FloatType.double) let function = builder.addFunction(prototype.name, type: funcType) for (var param, name) in zip(function.parameters, prototype.params) { param.name = name } return function } // declare double @foo(double %n, double %m)
90. @discardableResult func emitDefinition(_ definition: Definition) throws -> Function { let function = emitPrototype(definition.prototype)
91. @discardableResult func emitDefinition(_ definition: Definition) throws -> Function { let function = emitPrototype(definition.prototype) for (idx, arg) in definition.prototype.params.enumerated() { let param = function.parameter(at: idx)! parameterValues[arg] = param }
92. @discardableResult func emitDefinition(_ definition: Definition) throws -> Function { let function = emitPrototype(definition.prototype) for (idx, arg) in definition.prototype.params.enumerated() { let param = function.parameter(at: idx)! parameterValues[arg] = param } let entryBlock = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entryBlock)
93. #BTJD
    #MPDLT define double @plusOne(double %n) { entry: %r = fadd double %n, 1.000000e+00 br %next next: %g = fmul double %r, 1.100000e+00 ret double %g }
94. @discardableResult func emitDefinition(_ definition: Definition) throws -> Function { let function = emitPrototype(definition.prototype) for (idx, arg) in definition.prototype.params.enumerated() { let param = function.parameter(at: idx)! parameterValues[arg] = param } let entryBlock = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entryBlock)
95. @discardableResult func emitDefinition(_ definition: Definition) throws -> Function { let function = emitPrototype(definition.prototype) for (idx, arg) in definition.prototype.params.enumerated() { let param = function.parameter(at: idx)! parameterValues[arg] = param } let entryBlock = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entryBlock) let expr = try emitExpr(definition.expr) builder.buildRet(expr)
96. @discardableResult func emitDefinition(_ definition: Definition) throws -> Function { let function = emitPrototype(definition.prototype) for (idx, arg) in definition.prototype.params.enumerated() { let param = function.parameter(at: idx)! parameterValues[arg] = param } let entryBlock = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entryBlock) let expr = try emitExpr(definition.expr) builder.buildRet(expr) parameterValues.removeAll() return function }
97. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr {
98. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr { case .number(let value): return FloatType.double.constant(value)
99. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr { case .number(let value): return FloatType.double.constant(value) case .variable(let name): guard let param = parameterValues[name] else { throw IRError.unknownVariable(name) } return param
100. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr { case .number(let value): return FloatType.double.constant(value) case .variable(let name): guard let param = parameterValues[name] else { throw IRError.unknownVariable(name) } return param case .call(let name, let args): guard let prototype = file.prototype(name: name) else { throw IRError.unknownFunction(name) }
101. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr { case .number(let value): return FloatType.double.constant(value) case .variable(let name): guard let param = parameterValues[name] else { throw IRError.unknownVariable(name) } return param guard prototype.params.count == args.count else { throw IRError.wrongNumberOfArgs(name, expected: prototype.params.count, got: args.count) } case .call(let name, let args): guard let prototype = file.prototype(name: name) else { throw IRError.unknownFunction(name) }
102. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr { case .number(let value): return FloatType.double.constant(value) case .variable(let name): guard let param = parameterValues[name] else { throw IRError.unknownVariable(name) } return param guard prototype.params.count == args.count else { throw IRError.wrongNumberOfArgs(name, expected: prototype.params.count, got: args.count) } let callArgs = try args.map(emitExpr) case .call(let name, let args): guard let prototype = file.prototype(name: name) else { throw IRError.unknownFunction(name) }
103. func emitExpr(_ expr: Expr) throws -> IRValue { switch expr { case .number(let value): return FloatType.double.constant(value) case .variable(let name): guard let param = parameterValues[name] else { throw IRError.unknownVariable(name) } return param guard prototype.params.count == args.count else { throw IRError.wrongNumberOfArgs(name, expected: prototype.params.count, got: args.count) } let callArgs = try args.map(emitExpr) let function = emitPrototype(prototype) case .call(let name, let args): guard let prototype = file.prototype(name: name) else { throw IRError.unknownFunction(name) } return builder.buildCall(function, args: callArgs)
104. case .binary(let lhs, let op, let rhs):
105. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs)
106. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs) switch op {
107. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs) switch op { case .plus: return builder.buildAdd(lhsVal, rhsVal)
108. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs) switch op { case .plus: return builder.buildAdd(lhsVal, rhsVal) case .minus: return builder.buildSub(lhsVal, rhsVal) case .divide: return builder.buildDiv(lhsVal, rhsVal) case .times: return builder.buildMul(lhsVal, rhsVal) case .mod: return builder.buildRem(lhsVal, rhsVal)
109. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs) switch op { case .plus: return builder.buildAdd(lhsVal, rhsVal) case .minus: return builder.buildSub(lhsVal, rhsVal) case .divide: return builder.buildDiv(lhsVal, rhsVal) case .times: return builder.buildMul(lhsVal, rhsVal) case .mod: return builder.buildRem(lhsVal, rhsVal) case .equals:
110. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs) switch op { case .plus: return builder.buildAdd(lhsVal, rhsVal) case .minus: return builder.buildSub(lhsVal, rhsVal) case .divide: return builder.buildDiv(lhsVal, rhsVal) case .times: return builder.buildMul(lhsVal, rhsVal) case .mod: return builder.buildRem(lhsVal, rhsVal) case .equals: let comparison = builder.buildFCmp(lhsVal, rhsVal, .orderedEqual)
111. case .binary(let lhs, let op, let rhs): let lhsVal = try emitExpr(lhs) let rhsVal = try emitExpr(rhs) switch op { case .plus: return builder.buildAdd(lhsVal, rhsVal) case .minus: return builder.buildSub(lhsVal, rhsVal) case .divide: return builder.buildDiv(lhsVal, rhsVal) case .times: return builder.buildMul(lhsVal, rhsVal) case .mod: return builder.buildRem(lhsVal, rhsVal) case .equals: return builder.buildIntToFP(comparison, type: FloatType.double, signed: false) } let comparison = builder.buildFCmp(lhsVal, rhsVal, .orderedEqual)
112. case .ifelse(let cond, let thenExpr, let elseExpr):
113. *G
     4UBUFNFOUT def simpleIf(n) if n then n + 1 else 0
114. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 def simpleIf(n) if n then n + 1 else 0
115. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 br i1 %cmp, label %then, label %else def simpleIf(n) if n then n + 1 else 0
116. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 br i1 %cmp, label %then, label %else then: %1 = fadd double %n, 1.000000e+00 br label %merge def simpleIf(n) if n then n + 1 else 0
117. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 br i1 %cmp, label %then, label %else then: %1 = fadd double %n, 1.000000e+00 br label %merge else: br label %merge def simpleIf(n) if n then n + 1 else 0
118. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 br i1 %cmp, label %then, label %else then: %1 = fadd double %n, 1.000000e+00 br label %merge else: br label %merge merge: %2 = phi double ret double %2 } def simpleIf(n) if n then n + 1 else 0 [ %1, %then ], [ 0.000000e+00, %else ]
119. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 br i1 %cmp, label %then, label %else then: %1 = fadd double %n, 1.000000e+00 br label %merge else: br label %merge merge: %2 = phi double ret double %2 } def simpleIf(n) if n then n + 1 else 0 [ %1, %then ], [ 0.000000e+00, %else ]
120. *G
     4UBUFNFOUT define double @simpleIf(double %n) { entry: %cmp = fcmp one double %n, 0.000000e+00 br i1 %cmp, label %then, label %else then: %1 = fadd double %n, 1.000000e+00 br label %merge else: br label %merge merge: %2 = phi double ret double %2 } def simpleIf(n) if n then n + 1 else 0 [ %1, %then ], [ 0.000000e+00, %else ]
121. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual)
122. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge")
123. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge") builder.buildCondBr(condition: checkCond, then: thenBB, else: elseBB)
124. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge") builder.buildCondBr(condition: checkCond, then: thenBB, else: elseBB) builder.positionAtEnd(of: thenBB) let thenVal = try emitExpr(thenExpr) builder.buildBr(mergeBB)
125. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge") builder.buildCondBr(condition: checkCond, then: thenBB, else: elseBB) builder.positionAtEnd(of: thenBB) let thenVal = try emitExpr(thenExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: elseBB) let elseVal = try emitExpr(elseExpr) builder.buildBr(mergeBB)
126. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge") builder.buildCondBr(condition: checkCond, then: thenBB, else: elseBB) builder.positionAtEnd(of: thenBB) let thenVal = try emitExpr(thenExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: elseBB) let elseVal = try emitExpr(elseExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: mergeBB)
127. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge") builder.buildCondBr(condition: checkCond, then: thenBB, else: elseBB) builder.positionAtEnd(of: thenBB) let thenVal = try emitExpr(thenExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: elseBB) let elseVal = try emitExpr(elseExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: mergeBB) let phi = builder.buildPhi(FloatType.double) phi.addIncoming([(thenVal, thenBB), (elseVal, elseBB)])
128. case .ifelse(let cond, let thenExpr, let elseExpr): let checkCond = builder.buildFCmp(try emitExpr(cond), FloatType.double.constant(0.0), .orderedNotEqual) let thenBB = builder.currentFunction!.appendBasicBlock(named: "then") let elseBB = builder.currentFunction!.appendBasicBlock(named: "else") let mergeBB = builder.currentFunction!.appendBasicBlock(named: "merge") builder.buildCondBr(condition: checkCond, then: thenBB, else: elseBB) builder.positionAtEnd(of: thenBB) let thenVal = try emitExpr(thenExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: elseBB) let elseVal = try emitExpr(elseExpr) builder.buildBr(mergeBB) builder.positionAtEnd(of: mergeBB) let phi = builder.buildPhi(FloatType.double) phi.addIncoming([(thenVal, thenBB), (elseVal, elseBB)]) return phi }
129. func emitMain() throws {
130. func emitMain() throws { let mainType = FunctionType(argTypes: [], returnType: VoidType()) let function = builder.addFunction("main", type: mainType)
131. func emitMain() throws { let mainType = FunctionType(argTypes: [], returnType: VoidType()) let function = builder.addFunction("main", type: mainType) let entry = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entry) let formatString = builder.buildGlobalStringPtr("%f\n") let printf = emitPrintf()
132. func emitMain() throws { let mainType = FunctionType(argTypes: [], returnType: VoidType()) let function = builder.addFunction("main", type: mainType) let entry = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entry) let formatString = builder.buildGlobalStringPtr("%f\n") let printf = emitPrintf() for expr in file.expressions { let val = try emitExpr(expr) builder.buildCall(printf, args: [formatString, val]) }
133. func emitMain() throws { let mainType = FunctionType(argTypes: [], returnType: VoidType()) let function = builder.addFunction("main", type: mainType) let entry = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entry) let formatString = builder.buildGlobalStringPtr("%f\n") let printf = emitPrintf() builder.buildRetVoid() } for expr in file.expressions { let val = try emitExpr(expr) builder.buildCall(printf, args: [formatString, val]) }
134. func emitMain() throws { let mainType = FunctionType(argTypes: [], returnType: VoidType()) let function = builder.addFunction("main", type: mainType) let entry = function.appendBasicBlock(named: "entry") builder.positionAtEnd(of: entry) let formatString = builder.buildGlobalStringPtr("%f\n") let printf = emitPrintf() builder.buildRetVoid() } func emit() throws { for extern in file.externs { emitPrototype(extern) } for definition in file.definitions { try emitDefinition(definition) } try emitMain() } for expr in file.expressions { let val = try emitExpr(expr) builder.buildCall(printf, args: [formatString, val]) }
135. %FNP
136. *O
     %FQUI
     #MPH
     1PTUT IBSMBOIBTLJOTDPN .PSF
     *OGP
     PO
     --7. MMWNPSHEPDT 'VMM
     $PEF HJUIVCDPNUSJMMMBOH,BMFJEPTDPQF