Compiler 2018:
Big Picture
Lequn Chen
March 16, 2017
Why Compilers Course
• Improve programming skills
• ~10k loc
• Very important project experience in your CV
• programming skills
• perseverance
What Are Compilers
Compiler
Source Language Target Language
gcc
C Linux x86-64 ELF
javac
Java JVM Bytecode
your compiler
M* Linux x86-64 Assembly
What Are Virtual Machines
• Interpreter
• JIT Optimization focused on Code Generation
Java JVM on x86-64 Linux
Kotlin JVM on x86-64 Windows
JVM Bytecode
Scala JVM on x86-64 macOS
Clojure JVM on Embedded Systems
• Language Features
• Optimization based on High Level Semantics
not Low-Level Virtual Machine anymore
LLVM
• Code Generation
• Transforms and Optimizations
C/C++ x86-64
Rust RISC
LLVM IR
Swift ARM
Haskell MIPS
• Language Features
• Optimization based on High Level Semantics
not Low-Level Virtual Machine anymore
LLVM
• Code Generation
Front-end • Transforms and Optimizations
C/C++ x86-64
Back-end
Rust RISC
LLVM IR
Swift ARM
Haskell MIPS
• Language Features
• Optimization based on High Level Semantics
Compilers
• Overview
• Front-end → Intermediate Representation → Back-end
• More detail?
• Lexing
• Parsing
• Semantic Analysis
• IR Generation
• IR Optimization
• Code Generation
• Target-dependent Optimizations
About the Course
• Language: whatever you want
• Lexing and parsing library: whatever you want
• Source language: M* (C-and-Java-like)
• Target platform: Linux x86-64 Assembly in NASM
• Additional language features: whatever you want
• as long as it is compatible with the manual
• Optimizations: whatever you want
• as long as you can pass the tests
Lexing & Parsing
Source Code
while f3 < 100 {
f3 = f1 + f2;
f1, f2 = f2, f3;
}
Lexing
while f3 < 100 {
f3 = f1 + f2;
f1, f2 = f2, f3;
}
KEYWORD while
IDENTIFIER f3
SYMBOL <
LITERAL 100
SYMBOL {
IDENTIFIER f3
SYMBOL =
IDENTIFIER f1
SYMBOL +
IDENTIFIER f2
SYMBOL ;
IDENTIFIER f1
SYMBOL ,
IDENTIFIER f2
SYMBOL =
IDENTIFIER f2
SYMBOL ,
IDENTIFIER f3
SYMBOL ;
SYMBOL }
Parsing
while f3 < 100 {
f3 = f1 + f2;
f1, f2 = f2, f3;
}
KEYWORD while Abstract Syntax Tree
IDENTIFIER f3 WHILE
SYMBOL <
EXPRESSION BODY
LITERAL 100
SYMBOL { < STATEMENT STATEMENT
IDENTIFIER f3
SYMBOL = f3 100 ASSIGN UNPACKING
IDENTIFIER f1
SYMBOL + f3 EXPRESSION TARGET SOURCE
IDENTIFIER f2 + f1 f2 f2 f3
SYMBOL ;
IDENTIFIER f1 f1 f2
SYMBOL ,
IDENTIFIER f2
SYMBOL =
IDENTIFIER f2
SYMBOL ,
IDENTIFIER f3
SYMBOL ;
SYMBOL }
Syntax Error
while f3 < 100 {
f3 = f1 + f2;
f1, f2 = f2, f3;
}
KEYWORD while Abstract Syntax Tree
IDENTIFIER f3 WHILE
SYMBOL <
EXPRESSION BODY
LITERAL 100
SYMBOL { <
IDENTIFIER f3
SYMBOL = f3 100 ???
IDENTIFIER f1
SYMBOL +
IDENTIFIER f2
SYMBOL ;
IDENTIFIER f1
SYMBOL ,
IDENTIFIER f2
SYMBOL = Syntax Error: Expect loop body
IDENTIFIER f2
SYMBOL ,
IDENTIFIER f3
SYMBOL ;
SYMBOL }
Syntax Error
while f3 < 100 {
f3 = f1 + f2;
f1, f2 = f2, f3;
}
KEYWORD while Abstract Syntax Tree
IDENTIFIER f3 WHILE
SYMBOL <
EXPRESSION BODY
LITERAL 100
SYMBOL { < STATEMENT STATEMENT
IDENTIFIER f3
SYMBOL = f3 100 ASSIGN UNPACKING
IDENTIFIER f1
SYMBOL + f3 EXPRESSION TARGET SOURCE
IDENTIFIER f2 + f1 f2 f2 f3
SYMBOL ;
IDENTIFIER f1 f1 f2
SYMBOL ,
IDENTIFIER f2
SYMBOL = Syntax Error: Missing }
IDENTIFIER f2
SYMBOL ,
IDENTIFIER f3
SYMBOL ;
SYMBOL }
Parsing: Grammars
stmt: expr NEWLINE
| ID '=' expr NEWLINE
| NEWLINE
;
expr: <assoc=right> expr op='^' expr
| expr op=('*'|'/') expr a = 2
| expr op=('+'|'-') expr
| INT b = 3
| ID c = 4 + a * b
| '(' expr ')'
d = 5 - c * (3 + b) / a
MUL : '*';
DIV : '/';
e = a ^ (b + 10) ^ c ^ d
ADD : '+';
SUB : '-';
ID : Letter LetterOrDigit*
fragment Letter: [a-zA-Z_]
fragment Digit: [0-9]
fragment LetterOrDigit: Letter | Digit
NEWLINE: '\r'? '\n'
WS : [ \t]+ -> skip
Parsing: Grammars
Parsing: Grammars
Expr → Expr + Term Expr → Term Expr’
| Expr - Term Expr’ → + Term Expr’
LL ✘ LL ✔
| Term | - Term Expr’
LR ✔ | Ɛ LR ✔
Term → Term * Factor
| Term / Factor Term → Factor Term’
Term’ → * Factor Term’
Factor → ( Expr ) | / Factor Term’
| Integer | Ɛ
Factor → ( Expr )
| Integer
def Expr():
Expr()
match('+') Infinite Recursion!
Term()
Lexer & Parser?
• Usually, lexer and parser can be completely separated.
• However,
• vector<pair<int, int>>
Pragmatic Solution
• What to do
• Build AST
• Check syntax errors
• Use parser generators, especially, ANTLR 4
• Check https://github.com/antlr/grammars-v4
• Read if you want
• https://abcdabcd987.com/using-antlr4/
• https://abcdabcd987.com/notes-on-antlr4/
Challenge Yourself
• Hand-written lexer and parser
• Check Parsing Techniques: A Practical Guide
Semantic Analysis
Semantic Error
while f3 < 100 {
f3 = f1 + f4;
f1, f2 = f2, f3;
}
KEYWORD while Abstract Syntax Tree
IDENTIFIER f3 WHILE
SYMBOL <
EXPRESSION BODY
LITERAL 100
SYMBOL { < STATEMENT STATEMENT
IDENTIFIER f3
SYMBOL = f3 100 ASSIGN UNPACKING
IDENTIFIER f1
SYMBOL + f3 EXPRESSION TARGET SOURCE
IDENTIFIER f2 + f1 f2 f2 f3
SYMBOL ;
IDENTIFIER f1 f1 f4
SYMBOL ,
IDENTIFIER f2
SYMBOL = Semantic Error: f4 used before declaration
IDENTIFIER f2
SYMBOL ,
IDENTIFIER f3
SYMBOL ;
SYMBOL }
Language Features
• x, y = y, x
•c = sum(x * y for x in a for y in b)
• a.sort(key=lambda x: x[0])
Pragmatic Solution
• What to do
• Walk the AST tree
• Build symbol table
• Check all kinds of semantic errors
Challenge Yourself
• Add features to the language
• unpacking
• list comprehension
• lambda
• lifetimes
•…
IR Generation
IR: What & Why
• Intermediate Representation
• Focus less on the source language
• Pay more attention to the target platform
• Most of transformation and analysis are done in IR
IR Design
• IR design is closely related to
• Source language
• Target machine
• Transforms / Analysis
IR: Multiple Levels
• A compiler can use more than one IR, and of course, there
are more than one level.
• HIR/MIR: Carry more information. May have type system
similar to the source language. Higher level analysis &
transforms can be performed on. (Alias analysis works
better with type knowledge)
• point1.x => (LoadField point1 “x”)
• LIR: Closer to the target machine. Don’t have much type
information (General/FP Reg). Focus on code generation.
• point1.x => (LoadMem (Mem baseAddr 4))
IR: Multiple Levels
• A compiler can use more than one IR, and of course,
there are more than one level.
• LLVM: Low Level Virtual Machine
• Actually, its level is not that low.
• And it happens that LLVM use a single representation.
• The more information you own, the more chances you
have to do analysis and transforms.
LLVM IR
• LLVM: almost keep everything!
struct RT {
char A;
%struct.RT = type { i8, [10 x [20 x i32]], i8 }
int B[10][20];
%struct.ST = type { i32, double, %struct.RT }
char C;
};
define i32* @foo(%struct.ST* %s) {
struct ST {
entry:
int X;
%arrayidx = getelementptr inbounds %struct.ST,
double Y;
%struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
struct RT Z;
ret i32* %arrayidx
};
}
int *foo(struct ST *s) {
return &s[1].Z.B[5][13];
}
IR Design: Structure
• Tree (the Tiger Book)
• ✘ I cannot understand it
• ✘ Hard to analyze and transform
• Linear (the Dragon Book)
• ✘ Hard to analyze and transform
• Control Flow Graph
• ✔ Easy to build CFG IR
• ✔ Further analysis and transformations need CFG
Control Flow Graph
if x > y
if x > y:
z = x
foo()
z = x z = y
else: foo() bar()
z = y
bar()
print(z)
print(z)
• Node: Basic Block
• BB: Straight-line piece of code without any jumps or jump targets
• Directed Edge: Jumps
Design: Memory Model?
• Memory-to-Memory
• Reg Alloc: What should be keep in registers?
• ✘ Lots of students wasted lots of time on it
• Register-to-Register:
• Unlimited virtual register
• Reg Alloc: What should be spilled to memory?
• ✔ Easy to understand
• ✔ Similar to the target platform
Design: Function?
• Should the “function” and “function call” concept
present in IR?
• I’m strongly in favor of it
• ✔ Simplify things
• Function call doesn’t split basic block
• In optimization’s language, “global” means inside a
function, not the whole program.
Debugging
• I printed my IR in LLVM’s format and run
• Painful!
• No direct memory arithmetic!
• I wrote my own interpreter
• https://github.com/abcdabcd987/LLIRInterpreter
• Life is much more easier!
Pragmatic Solution
• What to do
• Walk the AST tree
• Generate IR
• IR Design
• Use CFG IR. Don’t use tree IR or linear IR.
• Use register-to-register memory model
• Check senior students’ design for reference, for example
• https://github.com/abcdabcd987/LLIRInterpreter
Challenge Yourself
• Design your own IR
• Read for your reference if you want:
• https://speakerdeck.com/abcdabcd987/
compiler2016-by-abcdabcd987
Optimizations
Optimizations
• Loop optimizations
• Loop unrolling • Code generator optimization
• Software pipelining
• Register allocation
• Data-flow optimizations • Instruction selection
• Common subexpression • Instruction scheduling
elimination
• Constant folding and • Others
propagation • Dead code elimination
• Inlining
• SSA-based optimizations
• Global value numbering • …
• Sparse conditional constant
propagation
Register Allocation
• Register-to-register IR: infinite virtual registers
• Real machine: limited number of registers
• Register allocation: map virtual registers to real registers
• Spilling: which virtual registers should move to memory
Register Allocation
• Linear scan algorithm
• ✔ Sounds easier?
• ✔ Allocate faster
• ✘ Slightly worse run time
• Graph coloring algorithm
• ✘ Liveness analysis
• ✘ Write more lines of code
• ✔ Better run time performance
• ✔ Actually, not hard at all. Way simpler than lots of OI/ACM
algorithms.
Pragmatic Solution
• What to do
• Analyze and transform IR
• Graph coloring register allocation
• Inlining
Challenge Yourself
• Try all kinds of optimizations
Code Generation
Pragmatic Solution
• What to do
• Transform IR to target machine assembly
• Do it in a naïve way
Challenge Yourself
• Dive further into x86-64
• Instruction selection
• Instruction scheduling
Standard Library
Pragmatic Solution
• Use libc
Challenge Yourself
• Write your own standard library
• Write your own heap memory allocator
Wrap Up
Pragmatic Solution
• Use ANTLR 4. Imitate existing ANTLR 4 grammars.
• Use CFG IR. Use register-to-register model.
• Use graph coloring register allocation.
• Use libc
• Talk to classmates, TAs, senior students
• Ask for help. Don’t plagiarize others’ code.
Challenge Yourself
• And help others
