The original talk was presented in TGSA (http://clubs.uci.edu/tgsa/) Academic Friday, December 6th 2020. Most of the contents are written in English. Except some Chinese memes.

1. 馴龍⾼⼿101-淺談現代編譯技術
Min-Yih Hsu 許⺠易 <minyihh@uci.edu>
How to Train Your Dragon
- Intro to Modern Compiler Techniques

2. Who Am I?

3. Who Am I?
• Computer Science PhD @ UCI

4. Who Am I?
• Computer Science PhD @ UCI
• Interests: Compiler, Static Analysis,
System Software

5. Who Am I?
• Computer Science PhD @ UCI
• Interests: Compiler, Static Analysis,
System Software
• LLVM Contributor

6. Who Am I?
• Computer Science PhD @ UCI
• Interests: Compiler, Static Analysis,
System Software
• LLVM Contributor
• Chocolate and Coffee Junkies

7. Who Am I?
• Computer Science PhD @ UCI
• Interests: Compiler, Static Analysis,
System Software
• LLVM Contributor
• Chocolate and Coffee Junkies
• https://myhsu.xyz

8. What is Compiler?

9. What is Compiler?
void main() {
printf(“Hello World!n”);
}

10. What is Compiler?
void main() {
printf(“Hello World!n”);
}

11. What is Compiler?
void main() {
printf(“Hello World!n”);
}

12. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!

13. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Compiler

14. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!

15. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Computer Human

16. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Computer Human

17. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Computer Human
Computer Human

18. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Compiler
Computer Human
Computer Human

19. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Compiler
Computer Human
Computer Human

20. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Compiler
Computer Human
Computer Human

21. Undergrad Compiler Class Like…

22. Undergrad Compiler Class Like…

23. Undergrad Compiler Class Like…

24. Undergrad Compiler Class Like…

25. Undergrad Compiler Class Like…

26. Undergrad Compiler Class Like…

27. Undergrad Compiler Class Like…

28. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Compiler
Computer Human
Computer Human

29. What is Compiler?
void main() {
printf(“Hello World!n”);
}
C:/> my_first_program
Hello World!
Compiler
Computer Human
Computer Human
EASY
PEASY

30. THE END

31. THE END

32. Why Compilers are NOT Easy?

33. Why Dragon?

34. Why Dragon?

35. Why Dragon?

36. Why Dragon?

37. Why Dragon?

38. Why Dragon?

39. Why Dragon?
“Complexity of Compiler Design”

40. (Some) Sources of Complexities

41. (Some) Sources of Complexities
• Translation
• How do I translate source code into machine binary?

42. (Some) Sources of Complexities
• Translation
• How do I translate source code into machine binary?
• Optimization
• How do I generate machine binaries that run fast?

43. (Some) Sources of Complexities
• Translation
• How do I translate source code into machine binary?
• Optimization
• How do I generate machine binaries that run fast?
• Portability
• How do I support N different programming languages and M
different machines in the same compiler?

44. (Some) Sources of Complexities
• Translation
• How do I translate source code into machine binary?
• Optimization
• How do I generate machine binaries that run fast?
• Portability
• How do I support N different programming languages and M
different machines in the same compiler?

45. Optimizations

46. Why We Need Compiler Optimizations?
int foo(int x) {
return x + x + x + x +…(1000 times);
}
Source Code

47. Why We Need Compiler Optimizations?
int foo(int x) {
return x + x + x + x +…(1000 times);
}
Source Code
r0 = add x, x
r1 = add r0, x
r2 = add r1, x
r3 = add r2, x
…
result = add r997, x
“Naive” Machine Code

48. Why We Need Compiler Optimizations?
int foo(int x) {
return x + x + x + x +…(1000 times);
}
Source Code
r0 = add x, x
r1 = add r0, x
r2 = add r1, x
r3 = add r2, x
…
result = add r997, x
“Naive” Machine Code
result = mul x, 1000
Optimal Machine Code

49. Why We Need Compiler Optimizations?
int foo(int x) {
return x + x + x + x +…(1000 times);
}
Source Code
r0 = add x, x
r1 = add r0, x
r2 = add r1, x
r3 = add r2, x
…
result = add r997, x
“Naive” Machine Code
result = mul x, 1000
Optimal Machine Code
“IMPOSSIBLE for programmers to write these!”

50. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}

51. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
a = 10 * 1000 = 10000

52. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
a = 10 * 1000 = 10000
b = 5 * 1000 = 5000

53. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
a = 10 * 1000 = 10000
b = 5 * 1000 = 5000
a + b = 10000 + 5000 = 15000

54. Why We Need Compiler Optimizations?
int bar() {
return 15000;
}
Expected

55. Why We Need Compiler Optimizations?
int bar() {
return 15000;
}
Expected
int foo(int x) {
return x * 1000;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
Compiler w/o
Optimization

56. Why We Need Compiler Optimizations?
int bar() {
return 15000;
}
Expected
int foo(int x) {
return x * 1000;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
Compiler w/o
Optimization
“IMPOSSIBLE for programmers to write these!”

57. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
int sum = 0;
if(n % 4 != 0) return 0;
for(int i=0; i < n; i++) {
int e = 1;
for(int r = i % 4; r > 0; r-=1) {
e *= 2;
}
sum += foo(e);
}
return sum;
}

58. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
int sum = 0;
if(n % 4 != 0) return 0;
for(int i=0; i < n; i++) {
int e = 1;
for(int r = i % 4; r > 0; r-=1) {
e *= 2;
}
sum += foo(e);
}
return sum;
}
………

59. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
if(n % 4 != 0) return 0;
return bar() * (n / 4);
}

60. Why We Need Compiler Optimizations?

61. Why We Need Compiler Optimizations?
• Fix stupid code written by programmers.

62. Why We Need Compiler Optimizations?
• Fix stupid code written by programmers. “IMPOSSIBLE!”

63. Why We Need Compiler Optimizations?
• Fix stupid code written by programmers.
• Not every code can be “optimized” by human.
“IMPOSSIBLE!”

64. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
int sum = 0;
if(n % 4 != 0) return 0;
for(int i=0; i < n; i++) {
int e = 1;
for(int r = i % 4; r >= 0; r-=1) {
e *= 2;
}
sum += foo(e);
}
return sum;
}

65. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
int sum = 0;
if(n % 4 != 0) return 0;
for(int i=0; i < n; i++) {
int e = 1;
for(int r = i % 4; r >= 0; r-=1) {
e *= 2;
}
sum += foo(e);
}
return sum;
}
Another Number

66. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
int sum = 0;
if(n % 4 != 0) return 0;
for(int i=0; i < n; i++) {
int e = 1;
for(int r = i % 4; r >= 0; r-=1) {
e *= 2;
}
sum += foo(e);
}
return sum;
}
Another Number
Another Number

67. Why We Need Compiler Optimizations?
int foo(int x) {
return x * 1000;
}
int bar() {
return 15000;
}
int zoo(int n) {
int sum = 0;
if(n % 4 != 0) return 0;
for(int i=0; i < n; i++) {
int e = 1;
for(int r = i % 4; r >= 0; r-=1) {
e *= 2;
}
sum += foo(e);
}
return sum;
}
Another Number
Another Number
?

68. Why We Need Compiler Optimizations?
“IMPOSSIBLE!”

69. Why We Need Compiler Optimizations?
• Fix stupid code written by programmers.
• Not every code can be “optimized” by human!
• Programmers can focus on program logics.
“IMPOSSIBLE!”

70. Why We Need Compiler Optimizations?
• Fix stupid code written by programmers.
• Not every code can be “optimized” by human!
• Programmers can focus on program logics.
• Without putting too many attentions on optimizing code.
“IMPOSSIBLE!”

71. Why We Need Compiler Optimizations?
• Fix stupid code written by programmers.
• Not every code can be “optimized” by human!
• Programmers can focus on program logics.
• Without putting too many attentions on optimizing code.
• Compilers will optimize code for you if applicable.
“IMPOSSIBLE!”

72. Compiler Optimizations And More

73. Compiler Optimization and More
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}

74. Compiler Optimization and More
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
A: Simplify the loop

75. Compiler Optimization and More
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
A: Simplify the loop
B: Simplify function calls

76. Compiler Optimization and More
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

77. Optimization Order Matters!
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

78. Optimization Order Matters!
int bar() {
return 15000;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

79. Optimization Order Matters!
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

80. Optimization Order Matters!
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants
What are the values?

81. Optimization Order Matters!
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

82. Optimization Order Matters!
int bar() {
int a = 0;
for(int I = 0; I < 1000; I++) {
a += 10;
}
int b = 0;
for(int I = 0; I < 1000; I++) {
b += 5;
}
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

83. Optimization Order Matters!
int bar() {
int a = 0;
for(int I = 0; I < 1000; I++) {
a += 10;
}
int b = 0;
for(int I = 0; I < 1000; I++) {
b += 5;
}
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

84. Optimization Order Matters!
int bar() {
int a = 0;
for(int I = 0; I < 1000; I++) {
a += 10;
}
int b = 0;
for(int I = 0; I < 1000; I++) {
b += 5;
}
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants
What are the values?

85. Compiler Optimization and More
int foo(int x) {
int sum = 0;
for(int I = 0; I < 8; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}

86. Compiler Optimization and More
Computer

87. Compiler Optimization and More
Computer

88. Compiler Optimization and More
Computer
Really Fast

89. Summation usingVector Adds
x + x + x + x + x + x + x + x

90. Summation usingVector Adds
x + x + x + x + x + x + x + x
V1 = <x, x, x, x>

91. Summation usingVector Adds
x + x + x + x + x + x + x + x
V1 = <x, x, x, x> V2 = <x, x, x, x>

92. Summation usingVector Adds
x + x + x + x + x + x + x + x
V1 = <x, x, x, x> V2 = <x, x, x, x>
V1 + V2 = <2x, 2x, 2x, 2x>

93. Summation usingVector Adds
Original: 8 summations
x + x + x + x
+ x + x + x + x
= 8x

94. Summation usingVector Adds
<x, x, x, x, x, x, x, x>
<2x, 2x, 2x, 2x>
<4x, 4x>
<8x>
Original: 8 summations New: 3 summations
x + x + x + x
+ x + x + x + x
= 8x

95. Portability

96. C/C++
Go
Swift
X86
ARM
Multi-Language and Machine:Traditional Approach

97. C/C++
Go
Swift
X86
ARM
Individual compiler
Multi-Language and Machine:Traditional Approach

98. C/C++
Go
Swift
X86
ARM
Individual compiler
Multi-Language and Machine:Traditional Approach

99. C/C++
Go
Swift
X86
ARM
Individual compiler
?
Multi-Language and Machine

100. Multi-Language and Machine
Intermediate Representation (IR)

101. Multi-Language and Machine
C/C++ to IR
Go to IR
Swift to IR
Intermediate Representation (IR)

102. Multi-Language and Machine
Optimizer
Working on IR
C/C++ to IR
Go to IR
Swift to IR
Intermediate Representation (IR)

103. Multi-Language and Machine
Optimizer
Working on IR
C/C++ to IR
Go to IR
Swift to IR
Intermediate Representation (IR)
IR to X86
IR to ARM

104. Recap: Compiler Optimizations
int foo(int x) {
int sum = 0;
for(int I = 0; I < 1000; I++) {
sum += x;
}
return sum;
}
int bar() {
int a = foo(10);
int b = foo(5);
return a + b;
}
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

105. C/C++
Go
Swift
X86
ARM
Individual compiler
Multi-Language and Machine:Traditional Approach
Need 6 versions of
A: Simplify the loop
B: Simplify function calls
C: Simplify constants

106. Multi-Language and Machine
Optimizer
Working on IR
C/C++ to IR
Go to IR
Swift to IR
Intermediate Representation (IR)
IR to X86
IR to ARM
A: Simplify the loop
B: Simplify function calls
C: Simplify constants
(Only ONE version!)

107. The IR in Previous Page

108. The IR in Previous Page
• “Machine Independent”
• Describe the operations instead of telling How to perform them
in different machines.

109. The IR in Previous Page
• “Machine Independent”
• Describe the operations instead of telling How to perform them
in different machines.
• “IR to X86” and “IR to ARM” .etc would translate IR to specific
machine code.
• This process is usually called lowering.

110. The IR in Previous Page
• “Machine Independent”
• Describe the operations instead of telling How to perform them
in different machines.
• “IR to X86” and “IR to ARM” .etc would translate IR to specific
machine code.
• This process is usually called lowering.
• Developers of optimizations don’t need to worry too much about
the target machine.

111. PROBLEM SOLVED

112. PROBLEM SOLVED

113. Recap:The “Magic”Vector Computer
Computer

114. Recap:The “Magic”Vector Computer
Computer
What If A Machine
DOESN’T Have This Feature?

115. Common
Optimizer
Language
Intermediate Representation (IR)
Machine

116. Common
Optimizer
Language
Intermediate Representation (IR)
Machine
Do you have ?

117. Common
Optimizer
Language
Intermediate Representation (IR)
Machine
Do you have ?
Do you have feature X ?

118. Common
Optimizer
Language
Intermediate Representation (IR)
Machine
Do you have ?
Do you have feature X ?
Do you have feature Y ?

119. Common
Optimizer
Language
Intermediate Representation (IR)
Machine
Do you have ?
Do you have feature X ?
Do you have feature Y ?
Do you have… ?

120. Common
Optimizer
Language
Intermediate Representation (IR)
Machine
Do you have ?
Do you have feature X ?
Do you have feature Y ?
Do you have… ?

121. Multiply Rule for Inverse Matrix
A x A-1 = I
Matrix foo(Matrix A) {
return A * inverse(A);
}
A Code Snippet

122. Case 1: IR Specialized for Certain Machine
proc foo(Matrix $a)-> Matrix {
$b = call inverse($a)
$c = mul $a, $b
return $c
}

123. Case 1: IR Specialized for Certain Machine
proc foo(Matrix $a)-> Matrix {
$b = call inverse($a)
$c = mul $a, $b
return $c
}
The optimizer says:
“A matrix multiplied with inverted version of itself”
“That’s easy: $c can be replaced with identity matrix!”

124. Case 2: General IR
int[][] foo(int[][] %a) {
%b = call inverse(%a)
for(…) {
for(…) {
for(…) {…}
}
}
}

125. Case 2: General IR
int[][] foo(int[][] %a) {
%b = call inverse(%a)
for(…) {
for(…) {
for(…) {…}
}
}
}
Matrix Multiplication

126. Case 2: General IR
int[][] foo(int[][] %a) {
%b = call inverse(%a)
for(…) {
for(…) {
for(…) {…}
}
}
}
The optimizer says:
“WTF”
“This is too difficult to optimize”
Matrix Multiplication

128. High engineering cost

129. Optimizations are specialized
for certain language / machine
High engineering cost

130. Optimizations are specialized
for certain language / machine
High engineering cost
Shared large portion of
optimization code base
among languages and machine.

131. Optimizations are specialized
for certain language / machine
High engineering cost
Shared large portion of
optimization code base
among languages and machine.
IR is usually too high-level.
Hard to describe machine
or language-specific optimizations

132. Compiler Design:Abstraction Level
Specialized
for certain machine / language
General / Re-usable
across different machines / languages

133. Epilogue

134. I Hope NowYou BelieveThat…
Compiler
is EASY… 並沒有

135. I HopeYou Learned…

136. I HopeYou Learned…
• What is Compiler

137. I HopeYou Learned…
• What is Compiler
• Why we need compiler optimizations
• Developers can focus on program logics without worrying too
much on runtime performance

138. I HopeYou Learned…
• What is Compiler
• Why we need compiler optimizations
• Developers can focus on program logics without worrying too
much on runtime performance
• Some details of optimizations I introduced earlier

139. I HopeYou Learned…
• What is Compiler
• Why we need compiler optimizations
• Developers can focus on program logics without worrying too
much on runtime performance
• Some details of optimizations I introduced earlier
• Difficulty of supporting a compiler for different languages and
machines

140. I HopeYou Learned…
• What is Compiler
• Why we need compiler optimizations
• Developers can focus on program logics without worrying too
much on runtime performance
• Some details of optimizations I introduced earlier
• Difficulty of supporting a compiler for different languages and
machines
• Difficulty of compilers to choose a proper abstraction level

141. Compiler
Research
Me

142. Finally, I HopeYou…
ENJOYED
THE MEMES
~ Thank You ~