Spring 2010
Lecture 1: Introduction
Intro. to Computer Language Engineering
Course Administration info
info.
Outline
• Course Administration Information
• Introduction to computer language engineering
– Why do we need a compiler?
– What are compilers?
– Anatomy of a compiler
Saman Amarasinghe
2
6.035
©MIT Fall 1998
Course Administration
•
•
•
•
•
•
Staff
Optional Text
Course Outline
The Project
j
Project Groups
Grading
Saman Amarasinghe
3
6.035
©MIT Fall 1998
Reference Textbooks
Modern Compiler Implementation in Java (Tiger book)
A textbook tutorial on compiler
implementation, including
techniques for many language
features
•
Advanced Compiler Design and Implementation (Whale book)
Essentially a recipe book of
optimizations;
ti i ti
very complete
l t and
d
suited for industrial practitioners
and researchers.
•
Compilers: Principles,
Principles Techniques and Tools (Dragon book)
The classic
Th
l i compilers
il
textbook,
t tb k
although its front-end emphasis
reflects its age. New edition has
more optimization material.
•
Engineering a Compiler (Ark book)
A modern classroom textbook,
with increased emphasis on the
back-end and implementation
techniques
techniques.
•
Optimizing Compilers for Modern Architectures
A modern textbook that focuses
on optimizations including
parallelization and memory
hierarchy optimization
•
A.W. Appel
Cambridge University Press, 1998
ISBN 0-52158-388-8
Steven Muchnick
Morgan Kaufman Publishers, 1997
ISBN 1-55860-320-4
Aho, Lam, Sethi and Ullman
Addison-Wesley, 2006
ISBN 0321486811
Keith D. Cooper, Linda Torczon
Morgan Kaufman Publishers, 2003
ISBN 1-55860
55860-698
698-X
X
Randy Allen and Ken Kennedy
Morgan Kaufman Publishers, 2001
ISBN 1-55860-286-0
Saman Amarasinghe
5
6.035
©MIT Fall 1998
The Project: The Five Segments

Lexical and Syntax Analysis
Semantic Analysis

Code Generation

Data-flow
Data
flow Analysis

Optimizations

Saman Amarasinghe
6
6.035
©MIT Fall 1998
Each Segment...
• Segment Start
– Project Description
• Lectures
– 2 to 5 lectures
• Project Time
– (Design Document)
– (Project Checkpoint)
• Project Due
Saman Amarasinghe
7
6.035
©MIT Fall 1998
Project Groups
• 1st project is an individual project
• Projects 2 to 5 are group projects consists of
3 to 4 students
• Grading
– All group members
b
(mostly)
(
tl ) gett the
th same grade
d
Saman Amarasinghe
8
6.035
©MIT Fall 1998
Grades
• Compiler project
70%
• In-class Quizzes
30% (10% each)
• In-class mini-quizzes
10% (0.5% each)
Saman Amarasinghe
10
6.035
©MIT Fall 1998
Grades for the Project
–
–
–
–
–
Scanner/Parser
S
Semantic
ti Checking
Ch ki
Code Generation
D t fl
Data-flow
Analysis
A l i
Optimizations
Saman Amarasinghe
5%
7 5%
7.5%
10%
7 5%
7.5%
30%
60%
11
6.035
©MIT Fall 1998
Optimization Segment
• Making programs run fast
–
–
–
–
We provide a test set of applications
Figure-out what will make them run fast
Prioritize and implement the optimizations
Compiler derby at the end
• A “similar” application to the test set is provided the day before
• The compiler that produced the fastest code is the winner
• Do any optimizations you choose
– Including parallelization for multicores
• Grade is divided into:
– Documentation
• Justifyy yyour optimizations
p
and the selection p
process
6%
– Optimization Implementation
12%
– Derby performance
12%
• Producing correct code
30%
Saman Amarasinghe
12
6.035
©MIT Fall 1998
The Quiz
• Three Quizzes
• In-Class Quiz
– 50 Minutes (be on time!)
– Open book, open notes
Saman Amarasinghe
13
6.035
©MIT Fall 1998
Mini Quizzes
• You already got one.
one
• Given at the beginning of the class; Collected at
th end
the
d
• Collaboration is OK
• This is in lieu of time consuming problem sets
Saman Amarasinghe
14
6.035
©MIT Fall 1998
Outline
• Course Administration Information
• Introduction to computer language engineering
– What are compilers?
– Why should we learn about them?
– Anatomy of a compiler
Saman Amarasinghe
15
6.035
©MIT Fall 1998
Why Study Compilers?
• Compilers enable programming at a high level
language instead of machine instructions.
– Malleability
Malleability, Portability,
Portability Modularity,
Modularity Simplicity,
Simplicity
Programmer Productivity
– Also Efficiency and Performance
Saman Amarasinghe
16
6.035
©MIT Fall 1998
Compilers Construction touches
many topics
t i in
i Computer
C
t Science
S i
• Theory
– Finite
Fi it State
St t A
Automata,
t
t G
Grammars and
dP
Parsing,
i
d
data-flow
t fl
• Algorithms
– Graph manipulation, dynamic programming
• Data structures
– Symbol tables, abstract syntax trees
• Systems
– Allocation and naming, multi-pass systems, compiler construction
• Computer Architecture
– Memory
M
hierarchy,
hi
h instruction
i t ti selection,
l ti
interlocks
i t l k and
d latencies,
l t
i
parallelism
ll li
• Security
– Detection of and Protection against vulnerabilities
• Software Engineering
– Software development environments, debugging
• Artificial Intelligence
– Heuristic based search for best optimizations
Saman Amarasinghe
17
6.035
©MIT Fall 1998
Power of a Language
• Can use to describe any action
– Not tied to a “context”
• Many
M
ways to
t d
describe
ib the
th same action
ti
– Flexible
Saman Amarasinghe
18
6.035
©MIT Fall 1998
How to instruct a computer
• How about natural languages?
–
–
–
–
English??
“Open the pod bay doors, Hal.”
“I am sorryDDave, I am afraid
f id I cannott do
d that”
th t”
We are not there yet!!
• Natural Languages:
– Powerful, but…
– Ambiguous
• Same expression describes many possible actions
Saman Amarasinghe
19
6.035
©MIT Fall 1998
Programming Languages
• Properties
–
–
–
–
need
need
need
need
Saman Amarasinghe
to
to
to
to
be
be
be
be
precise
concise
expressive
at a high-level (lot of abstractions)
20
6.035
©MIT Fall 1998
High-level Abstract Description
t Low-level
to
L
l
l Implementation
I
l
t ti
Details
D t il
My poll ratings are low,
lets invade a small nation
President
General
Cross the river and take
defensive positions
Sergeant
Forward march,
march turn left
Stop!, Shoot
Foot Soldier
Saman Amarasinghe
21
Figure by MIT OpenCourseWare.
6.035
©MIT Fall 1998
1. How to instruct the computer
• Write a program using a programming language
– High-level Abstract Description
• Microprocessors talk in assembly language
– Low-level Implementation Details
Program
written
in a
Programming
Languages
Saman Amarasinghe
Compiler
p
22
Assembly
Language
Translation
6.035
©MIT Fall 1998
1. How to instruct the computer
• Input: High-level
High level programming language
• Output: Low-level assembly instructions
• Compiler
p
does the translation:
–
–
–
–
Read and understand the program
Preciselyy determine what actions it require
q
Figure-out how to faithfully carry-out those actions
Instruct the computer to carry out those actions
Saman Amarasinghe
23
6.035
©MIT Fall 1998
Input to the Compiler
• Standard imperative language (Java,
(Java C,
C C++)
– State
• Variables,
Variables
• Structures,
y
• Arrays
– Computation
•
•
•
•
Expressions (arithmetic, logical, etc.)
Assignment statements
Control flow (conditionals, loops)
P
Procedures
d
Saman Amarasinghe
24
6.035
©MIT Fall 1998
Output of the Compiler
• State
– Registers
– Memory with Flat Address S
Space
pace
• Machine code – load/store architecture
– Load, store instructions
– Arithmetic, logical operations on registers
– Branch instructions
Saman Amarasinghe
25
6.035
©MIT Fall 1998
Example (input program)
int sumcalc(int a, int b, int N)
{
int i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*y;
}
return x;
}
Saman Amarasinghe
26
6.035
©MIT Fall 1998
Example (Output assembly code)
sumcalc:
.L2:
.L3:
Saman Amarasinghe
.size
pushq
movq
movl
movl
movl
movl
movl
movl
movl
cmpl
l
jg
movl
leal
leaq
movq
movl
movq
cltd
idivl
movl
movl
u
imull
movl
incl
imull
addl
leaq
addl
movl
movl
imull
leaq
addl
leaq
i l
incl
jmp
movl
leave
ret
sumcalc, .-sumcalc
.section
.Lframe1:
.long
.LECIE1-.LSCIE1
.LSCIE1:.long
0x0
.byte
0x1
.string ""
.uleb128 0x1
.sleb128 -8
.byte
0x10
.byte
b t
0
0xc
.uleb128 0x7
.uleb128 0x8
.byte
0x90
.uleb128 0x1
.align
8
.LECIE1:.long
LECIE1: long
.LEFDE1
LEFDE1-.LASFDE1
LASFDE1
.long
.LASFDE1-.Lframe1
.quad
.LFB2
.quad
.LFE2-.LFB2
.byte
0x4
.long
.LCFI0-.LFB2
.byte
0 e
0xe
.uleb128 0x10
.byte
0x86
.uleb128 0x2
.byte
0x4
.long
.LCFI1-.LCFI0
.byte
0xd
.uleb128 0x6
.align
8
%rbp
%rsp, %rbp
%edi, -4(%rbp)
%esi, -8(%rbp)
%edx, -12(%rbp)
$0, -20(%rbp)
$0, -24(%rbp)
$0, -16(%rbp)
-16(%rbp), %eax
-12(%rbp),
12(% b ) %
%eax
.L3
-4(%rbp), %eax
0(,%rax,4), %edx
-8(%rbp), %rax
%rax, -40(%rbp)
%edx %eax
%edx,
-40(%rbp), %rcx
(%rcx)
%eax, -28(%rbp)
-28(%rbp), %edx
-16(%rbp),
6(% bp), %ed
%edx
-16(%rbp), %eax
%eax
%eax, %eax
%eax, %edx
-20(%rbp), %rax
%edx, (%rax)
-8(%rbp), %eax
%eax, %edx
-24(%rbp), %edx
-20(%rbp), %rax
%edx, (%rax)
-16(%rbp), %rax
(%
(%rax)
)
.L2
-20(%rbp), %eax
27
6.035
©MIT Fall 1998
Mapping Time Continuum
C
Compilation
il ti
to
t Interpretation
I t
t ti
• Compile time
– Ex: C compiler
• Link
Li k time
ti
– Ex: Binary layout optimizer
• Load time
– Ex: JIT compiler
• Run time
– Ex: Java Interpreter
Saman Amarasinghe
28
6.035
©MIT Fall 1998
Anatomy of a Computer
Program
written
in a
Programming
Languages
Saman Amarasinghe
p
Compiler
29
Assembly
Language
Translation
6.035
©MIT Fall 1998
Anatomy of a Computer
Program (character stream)
L i l Analyzer
Lexical
A l
(Scanner)
(S
)
Token Stream
Saman Amarasinghe
30
6.035
©MIT Fall 1998
Lexical Analyzer (Scanner)
2 3 4
*
( 1 1
+ - 2 2 )
Num(234) mul_op lpar_op Num(11) add_op Num(-22) rpar_op
Saman Amarasinghe
31
6.035
©MIT Fall 1998
Lexical Analyzer (Scanner)
2 3 4
*
( 1 1
+ - 2 2 )
Num(234) mul_op lpar_op Num(11) add_op Num(-22) rpar_op
18..23 + val#ue
V i bl names cannott hhave ‘#’ character
Variable
h
t
Not a number
Saman Amarasinghe
32
6.035
©MIT Fall 1998
Anatomy of a Computer
Program (character stream)
L i lA
Lexical
Analyzer
l
(Scanner)
(S
)
Token Stream
Syntax Analyzer (Parser)
Parse Tree
Saman Amarasinghe
33
6.035
©MIT Fall 1998
Syntax Analyzer (Parser)
num ‘*’ ‘(‘ num ‘‘+’’ num ‘)’
<expr>
<expr>
num
<op>
<expr>
*
<expr>
(
<expr> <op>
num
Saman Amarasinghe
34
+
)
<expr>
num
6.035
©MIT Fall 1998
Syntax Analyzer (Parser)
int * foo(i, j, k))
int i;
int j;
Extra parentheses
{
for(i=0; i j) {
fi(i>j)
Missing increment
return j;
Not an expression
}
Not a keyword
Saman Amarasinghe
35
6.035
©MIT Fall 1998
Anatomy of a Computer
Program (character stream)
L i lA
Lexical
Analyzer
l
(Scanner)
(S
)
Token Stream
Syntax Analyzer (Parser)
Parse Tree
Semantic Analyzer
Intermediate Representation
Saman Amarasinghe
36
6.035
©MIT Fall 1998
Semantic Analyzer
int * foo(i, j, k)
int i;
int j;
{
int x;
x = x + j + N;
return j;
}
Saman Amarasinghe
37
Type not declared
Mismatched return type
Uninitialized variable used
Undeclared variable
6.035
©MIT Fall 1998
Anatomy of a Computer
Program (character stream)
L i lA
Lexical
Analyzer
l
(Scanner)
(S
)
Token Stream
Syntax Analyzer (Parser)
Parse Tree
Semantic Analyzer
Intermediate Representation
Code Optimizer
Optimized Intermediate Representation
Saman Amarasinghe
38
6.035
©MIT Fall 1998
Optimizer
int sumcalc(int a, int b, int N)
{
int i;
int x, t, u, v;
x = 0;
u = ((a<<2)/b);
v = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + v + t*t;
v = v + u;
}
return x;
}
int sumcalc(int a, int b, int N)
{
int i;
int x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x+4*a/b*i+(i+1)*(i+1);
x = x + b*y;
}
return x;
}
Saman Amarasinghe
39
6.035
©MIT Fall 1998
Anatomy of a Computer
Program (character stream)
L i lA
Lexical
Analyzer
l
(Scanner)
(S
)
Token Stream
Syntax Analyzer (Parser)
Parse Tree
Semantic Analyzer
Intermediate Representation
Code Optimizer
Optimized Intermediate Representation
Code Generator
Assembly code
Saman Amarasinghe
40
6.035
©MIT Fall 1998
Code Generator
int sumcalc(int a, int b, int N)
{
int i;
int x, t, u, v;
x = 0;
u = ((a<<2)/b);
(( <<2)/b)
v = 0;
for(i = 0; i <= N; i++) {
t = i+1;
;
x = x + v + t*t;
v = v + u;
}
return
t
x;
}
Saman Amarasinghe
41
sumcalc:
xorl
xorl
movl
cmpl
jg
sall
.L5:
movl
cltd
idivl
leal
movl
imull
movl
imull
leal
movl
addl
cmpl
jle
.L7:
movl
ret
%r8d, %r8d
%ecx
%ecx, %ecx
%edx, %r9d
%edx, %r8d
.L7
$2, %edi
, %eax
%edi,
%esi
1(%rcx), %edx
%eax, %r10d
%ecx, %r10d
%edx, %ecx
%edx, %ecx
(%r10,%rcx), %eax
%edx, %ecx
%eax, %r8d
% 9
%r9d,
%
%edx
.L5
%r8d, %eax
6.035
©MIT Fall 1998
Program Translation
• Correct
– The actions requested by the program has to be
faithfully executed
• Efficient
– Intelligently and efficiently use the available resources to
carry out the requests
– (the word optimization is used loosely in the compiler
community – Optimizing compilers are never optimal)
Saman Amarasinghe
42
6.035
©MIT Fall 1998
Efficient Execution
Cross the river and take
defensive positions
General
Sergeant
Foot Soldier
Figure by MIT OpenCourseWare.
Saman Amarasinghe
43
6.035
©MIT Fall 1998
Efficient Execution
Cross the river and take
defensive positions
General
Where to cross the river? Use the
bridge upstream or surprise the enemy
by crossing downstream?
How do I minimize the casualties??
Sergeant
Foot Soldier
Saman Amarasinghe
44
Figure by MIT OpenCourseWare.
6.035
©MIT Fall 1998
Efficient Execution
My poll ratings are low,
lets invade a small nation
President
Russia or Bermuda?
Or just stall for his poll
numbers to go up?
General
Figure by MIT OpenCourseWare.
Saman Amarasinghe
45
6.035
©MIT Fall 1998
Efficient Execution
• Mapping from High to Low
– Simple mapping of a program to assembly language
produces inefficient execution
– Higher the level of abstraction  more inefficiency
• If not efficient
– High-level abstractions are useless
• Need
d to:
– provide a high level abstraction
– with performance of giving low-level instructions
Saman Amarasinghe
46
6.035
©MIT Fall 1998
Efficient Execution help
i
increase
the
th llevell off abstraction
b t
ti
• Programming languages
– From C to OO-languages
with garbage collection
– Even more abstract
definitions
• Microprocessor
– From simple CISC to RISC to
VLIW to ….
Saman Amarasinghe
47
6.035
©MIT Fall 1998
The Multicore Dilemma
• Superscalars
• Multicores
High
g Level Language
g g
Simple von Neumann Machine
Multiple exposed cores
Harrd
warre
H
Hard
ware
w
Saman Amarasinghe
Co
omp
ile
er??
Com
pile
er
High Level Language
48
6.035
©MIT Fall 1998
The Multicore Dilemma
• Superscalars
• Multicores
Com
pile
er
High
g Level Language
g g
Simple von Neumann Machine
Multiple exposed cores
Harrd
warre
H
Hard
ware
w
Saman Amarasinghe
Com
m
pilerr
Parallel Language
49
6.035
©MIT Fall 1998
Optimization Example
int sumcalc(int a, int b, int N)
{
int i;
int x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*y;
}
return x;
}
Saman Amarasinghe
50
6.035
©MIT Fall 1998
pushq
%rbp
movq
%rsp, %rbp
movl
%edi, -4(%rbp)
movl
%esi, -8(%rbp)
movl
l
%
%edx,
d
-12(%rbp)
12(% b )
movl
$0, -20(%rbp)
movl
$0, -24(%rbp)
movl
$0, -16(%rbp)
.L2:
movl
-16(%rbp), %eax
cmpl
12(%rbp) %eax
12(%rbp),
jg
.L3
movl - -4(%rbp), %eax
leal
0(,%rax,4), %edx
leaq
-8(%rbp), %rax
movq
%rax
%rax, -40(%rbp)
40(%rbp)
movl
%edx, %eax
movq
-40(%rbp), %rcx
cltd
idivl
(%rcx)
movl
%eax,
, -28(%rbp)
(
p)
movl
-28(%rbp), %edx
imull
-16(%rbp), %edx
movl
-16(%rbp), %eax
incl
%eax
imull
%eax, %eax
addl
%eax, %edx
leaq
-20(%rbp), %rax
addl
%edx, (%rax)
movl
-8(%rbp), %eax
movl
%eax, %edx
i ll
imull
24(% b ) %
24(%rbp),
%edx
d
leaq - -20(%rbp), %rax
addl
%edx, (%rax)
leaq
-16(%rbp), %rax
incl
(%rax)
jmp
L2
.L3:
movl
-20(%rbp), %eax
leave
.
ret
Saman Amarasinghe
45
51
6.035
©MIT Fall 1998
Lets Optimize...
int sumcalc(int a, int b, int N)
{
int i, x, y;
x = 0;
y = 0;
o ( = 0
0;
; i <= N;
; i++)
) {
for(i
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*y;
}
return x;
}
Saman Amarasinghe
52
6.035
©MIT Fall 1998
Constant Propagation
int i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*y;
}
return x;
Saman Amarasinghe
53
6.035
©MIT Fall 1998
Constant Propagation
int i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*y;
}
return x;
Saman Amarasinghe
54
6.035
©MIT Fall 1998
Constant Propagation
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*0;
}
return x;
Saman Amarasinghe
55
6.035
©MIT Fall 1998
Algebraic Simplification
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*0;
}
return x;
Saman Amarasinghe
56
6.035
©MIT Fall 1998
Algebraic Simplification
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x + b*0;
}
return x;
Saman Amarasinghe
57
6.035
©MIT Fall 1998
Algebraic Simplification
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x;
}
return x;
Saman Amarasinghe
58
6.035
©MIT Fall 1998
Copy Propagation
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x;
}
return x;
Saman Amarasinghe
59
6.035
©MIT Fall 1998
Copy Propagation
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
x = x;
}
return x;
Saman Amarasinghe
60
6.035
©MIT Fall 1998
Copy Propagation
int
i
t i
i, x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
}
return x;
Saman Amarasinghe
61
6.035
©MIT Fall 1998
Common Subexpression Elimination
int i
i, x
x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
}
return x;
Saman Amarasinghe
62
6.035
©MIT Fall 1998
Common Subexpression Elimination
int i
i, x
x, y;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
x = x + (4*a/b)*i + (i+1)*(i+1);
}
return x;
Saman Amarasinghe
63
6.035
©MIT Fall 1998
Common Subexpression Elimination
int
i
t i
i, x, y, t;
t
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + (4*a/b)*i + t*t;
}
return x;
Saman Amarasinghe
64
6.035
©MIT Fall 1998
Dead Code Elimination
int
i
t i
i, x, y, t
t;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + (4*a/b)*i + t*t;
}
return x;
Saman Amarasinghe
65
6.035
©MIT Fall 1998
Dead Code Elimination
int
i
t i
i, x, y, t
t;
x = 0;
y = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + (4*a/b)*i + t*t;
}
return x;
Saman Amarasinghe
66
6.035
©MIT Fall 1998
Dead Code Elimination
int
i
t i
i, x, t;
t
x = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + (4*a/b)*i + t*t;
}
return x;
Saman Amarasinghe
67
6.035
©MIT Fall 1998
Loop Invariant Removal
int
i
t i
i, x, t;
t
x = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + (4*a/b)*i + t*t;
}
return x;
Saman Amarasinghe
68
6.035
©MIT Fall 1998
Loop Invariant Removal
int
i
t i
i, x, t;
t
x = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + (4*a/b)*i + t*t;
}
return x;
Saman Amarasinghe
69
6.035
©MIT Fall 1998
Loop Invariant Removal
int
i
t i
i, x, t,
t u;
x = 0;
u = (4*a/b);
/
for(i = 0; i <= N; i++) {
t = i+1;
x = x + u*i + t*t;
}
return x;
Saman Amarasinghe
70
6.035
©MIT Fall 1998
Strength Reduction
int
i
t i
i, x, t,
t u;
x = 0;
u = (4*a/b);
/
for(i = 0; i <= N; i++) {
t = i+1;
x = x + u*i + t*t;
}
return x;
Saman Amarasinghe
71
6.035
©MIT Fall 1998
Strength Reduction
int
i
t i
i, x, t,
t u;
x = 0;
u = (4*a/b);
/
for(i = 0; i <= N; i++) {
t = i+1;
x = x + u*i + t*t;
}
return x;
Saman Amarasinghe
72
6.035
©MIT Fall 1998
Strength Reduction
int i
i, x
x, t
t, u
u, v;
x = 0;
u = ((a<<2)/b);
v = 0;
for(i = 0; i <=
< N; i++) {
t = i+1;
x = x + v + t*t;
v = v + u;
}
return x;
Saman Amarasinghe
73
6.035
©MIT Fall 1998
Register Allocation
fp
Local variable X
Local variable Y
Local variable I
Saman Amarasinghe
74
6.035
©MIT Fall 1998
Register Allocation
fp
Local variable X
Local variable Y
Local variable I
$r8d
$r9d
$r10d
$ebx
$ecx
=
=
=
=
=
X
t
u
v
i
Saman Amarasinghe
75
6.035
©MIT Fall 1998
Optimized Example
int sumcalc(int a, int b, int N)
{
int i, x, t, u, v;
x = 0;
u = ((a<<2)/b);
v = 0;
for(i = 0; i <= N; i++) {
t = i+1;
x = x + v + t*t;
v = v + u;
}
return x;
}
Saman Amarasinghe
76
6.035
©MIT Fall 1998
Unoptimized Code
pushq
movq
movl
movl
movl
movl
movl
movl
.L2:
cmpl
movl
jg
movl
leal
leaq
movq
movl
movq
cltd
idi l
idivl
movl
movl
imull
movl
incl
imull
addl
leaq
addl
movl
movl
imull
leaq
addl
q
leaq
incl
jmp
.L3:
Optimized Code
xorl
xorl
movl
cmpl
jg
sall
%rbp
%rsp, %rbp
%edi, -4(%rbp)
4(%rbp)
%esi, -8(%rbp)
%edx, -12(%rbp)
$0, -20(%rbp)
$0, -24(%rbp)
$0, -16(%rbp)
-16(%rbp), %eax
-12(%rbp), %eax
.L3
L3
-4(%rbp), %eax
0(,%rax,4), %edx
-8(%rbp), %rax
%rax, -40(%rbp)
%edx, %eax
-40(%rbp), %rcx
.L5:
cltd
movl
idivl
leal
movl
imull
movl
imull
leal
movl
addl
cmpl
jl
jle
(%
(%rcx)
)
%eax, -28(%rbp)
-28(%rbp), %edx
-16(%rbp), %edx
-16(%rbp), %eax
%eax
%eax, %eax
%eax, %edx
-20(%rbp), %rax
%edx, (%rax)
-8(%rbp), %eax
%eax, %edx
-24(%rbp), %edx
-20(%rbp), %rax
%edx, (%rax)
-16(%rbp),
(
p), %rax
(%rax)
.L2
-20(%rbp), %eax
.L7:
%r8d, %r8d
%ecx, %ecx
%edx, %r9d
%edx, %r8d
.L7
$2, %edi
%edi, %eax
%esi
1(%rcx), %edx
%eax
%eax, %r10d
%ecx, %r10d
%edx, %ecx
%edx, %ecx
(%r10,%rcx), %eax
%edx, %ecx
%eax, %r8d
%r9d, %edx
.L5
L5
%r8d, %eax
ret
movl
leave
movl
ret
Inner Loop:
10*mov + 5*lea + 5*add/inc
+ 4*div/mul + 5*cmp/br/jmp
= 29 iinstructions
i
Execution time = 43 sec
Saman Amarasinghe
4*mov + 2*lea + 1*add/inc+
3*div/mul + 2*cmp/br/jmp
= 12 iinstructions
i
Execution time = 17 sec
77
6.035
©MIT Fall 1998
Compilers Optimize Programs for…
•
•
•
•
•
•
Performance/Speed
Code Size
Power Consumption
Fast/Efficient
/
Compilation
p
Security/Reliability
Debugging
Saman Amarasinghe
78
6.035
©MIT Fall 1998
MIT OpenCourseWare
http://ocw.mit.edu
6.035 Computer Language Engineering
Spring 2010
For information about citing these materials or our Terms of Use, visit: http://ocw.mit.edu/terms.