1

Compiler Construction

Overview

2

Today’s Goals

Summary of the subjects we’ve covered Perspectives and final remarks

3

High-level View

Definitions Compiler consumes source code & produces target code

usually translate high-level language programs into machine code

Interpreter consumes executables & produces results virtual machine for the input code

4

Why Study Compilers?

Compilers are important Enabling technology for languages, software development Allow programmers to focus on problem solving, hiding

the hardware complexity Responsible for good system performance

Compilers are useful Language processing is broadly applicable

Compilers are fun Combine theory and practice Overlap with other CS subjects Hard problems Engineering and trade-offs Got a taste in the labs!

5

Structure of Compilers

6

The Front-end

7

Lexical Analysis

Scanner Maps character stream into tokens

Automate scanner construction Define tokens using Regular Expressions Construct NFA (Nondeterministic Finite Automata) to recognize REs Transform NFA to DFA

Convert NFA to DFA through subset construction DFA minimization (set split)

Building scanners from DFA Tools

ANTLR, lex

8

Syntax Analysis

Parsing language using CFG (context-free grammar) CFG grammar theory

Derivation Parse tree Grammar ambiguity

Parsing Top-down parsing

recursive descent table-driven LL(1)

Bottom-up parsing LR(1) shift reduce parsing Operator precedence parsing Operator precedence parsing

9

Top-down Predictive Parsing

Basic ideaBuild parse tree from root. Given A → α | β,

use look-ahead symbol to choose between α & β

Recursive descent Table-driven LL(1)

Left recursion elimination

10

Bottom-up Shift-Reduce Parsing

Build reverse rightmost derivation The key is to find handle (rhs of production)

All active handles include top of stack (TOS) Shift inputs until TOS is right end of a handle

Language of handles is regular (finite) Build a handle-recognizing DFA ACTION & GOTO tables encode the DFA

11

Semantic Analysis

Analyze context and semantics types and other semantic checks

Attribute grammar associate evaluation rules with grammar

production Ad-hoc

build symbol table

12

Intermediate Representation

13

Intermediate Representation

Front-end translates program into IR format for further analysis and optimization IR encodes the compiler’s knowledge of the program Largely machine-independent Move closer to standard machine model

AST Tree: high-level Linear IR: low-level

ILOC 3-address code Assembly-level operations Expose control flow, memory addressing unlimited virtual registers

14

Procedure Abstraction

Procedure is key language construct for building large systems Name Space Caller-callee interface: linkage convention

Control transfer Context protection Parameter passing and return value

Run-time support for nested scopes Activation record, access link, display

Inheritance and dynamic dispatch for OO multiple inheritance virtual method table

15

The Back-end

16

The Back-end

Instruction selection Mapping IR into assembly code Assumes a fixed storage mapping & code shape Combining operations, using address modes

Instruction scheduling Reordering operations to hide latencies Assumes a fixed program (set of operations) Changes demand for registers

Register allocation Deciding which values will reside in registers Changes the storage mapping, may add false sharing Concerns about placement of data & memory operations

17

Code Generation

Expressions Recursive tree walk on AST Direct integration with parser

Assignment Array reference Boolean & Relational Values If-then-else Case Loop Procedure call

18

Instruction Selection

Hand-coded tree-walk code generator Automatic instruction selection

Pattern matching Peephole Matching Tree-pattern matching through tiling

19

Instruction Scheduling

The ProblemGiven a code fragment for some target machine and thelatencies for each individual operation, reorder the operationsto minimize execution time

Build Precedence GraphList scheduling

NP-complete problemHeuristics work well for basic blocks

forward list scheduling backward list scheduling

Scheduling for larger regions EBB and cloning Trace scheduling

20

Register Allocation

Local register allocation top-down bottom-up

Global register allocation Find live-range Build an interference graph GI Construct a k-coloring of interference graph Map colors onto physical registers

21

Web-based Live Ranges

Connect common defs and uses Solve the Reaching data-flow problem!

22

Interference Graph

The interference graph, GI

Nodes in GI represent live ranges Edges in GI represent individual interferences

For x, y ∈ GI, <x,y> ∈ iff x and y interfere

A k-coloring of GI can be mapped into an allocation to k registers

23

Key Observation on Coloring

Any vertex n that has fewer than k neighbors in the interference graph (n°< k) can always be colored !

Remove nodes n°< k for GI ’, coloring for GI ’ is also coloring for GI

24

Chaitin’s Algorithm

1. While ∃ vertices with < k neighbors in GI Pick any vertex n such that n°< k and put it on the stack Remove that vertex and all edges incident to it from GI

This will lower the degree of n’s neighbors

2. If GI is non-empty (all vertices have k or more neighbors) then: Pick a vertex n (using some heuristic) and spill the live range associated

with n Remove vertex n from GI , along with all edges incident to it and put it o

n the stack If this causes some vertex in GI to have fewer than k neighbors, then go

to step 1; otherwise, repeat step 23. If no spill, successively pop vertices off the stack and color them in t

he lowest color not used by some neighbor; otherwise, insert spill code, recompute GI and start from step 1

25

Brigg’s Improvement

Nodes can still be colored even with > k neighbors if some neighbors have same color

1. While ∃ vertices with < k neighbors in GI Pick any vertex n such that n°< k and put it on the stack Remove that vertex and all edges incident to it from GI

This may create vertices with fewer than k neighbors

2. If GI is non-empty (all vertices have k or more neighbors) then:

Pick a vertex n (using some heuristic condition), push n on the stack and remove n from GI , along with all edges incident to it

If this causes some vertex in GI to have fewer than k neighbors, then go to step 1; otherwise, repeat step 2

3. Successively pop vertices off the stack and color them in the lowest color not used by some neighbor

If some vertex cannot be colored, then pick an uncolored vertex to spill, spill it, and restart at step 1

26

The Middle-end: Optimizer

27

Principles of Compiler Optimization

safety Does applying the transformation change the results of

executing the code? profitability

Is there a reasonable expectation that applying the transformation will improve the code?

opportunity Can we efficiently and frequently find places to apply

optimization

Optimizing compiler Program Analysis Program Transformation

28

Program Analysis

Control-flow analysis Data-flow analysis

29

Control Flow Analysis

Basic blocks Control flow graph Dominator tree Natural loops Dominance frontier

the join points for SSA

insert Ф node

30

Data Flow Analysis

“compile-time reasoning about the runtime flow of values” represent effects of each basic block propagate facts around control flow graph

31

DFA: The Big Picture

Transfer function Forward analysis: compute OUT(B) in terms

IN(B) Available expressions Reaching definition

Backward analysis: compute IN(B) in terms of OUT(B)

Variable liveness Very busy expressions

Meet function for join points Forward analysis: combine OUT(p) of predec

essors to form IN(B) Backward analysis: combine IN(s) of succes

sors to form OUT(B)

Set up a set of equations that relate program properties at different program points in terms of the properties at "nearby" program points

32

Available ExpressionAvailable Expression

Basic block bBasic block b IN(b): expressions available at b’s entryIN(b): expressions available at b’s entry OUT(b): expressiongs available at b’s exitOUT(b): expressiongs available at b’s exit Local setsLocal sets

def(b): expressions defined in b and available on exitdef(b): expressions defined in b and available on exit killed(b): expressions killed in bkilled(b): expressions killed in b

An expression is killed in b if operands are assigned in bAn expression is killed in b if operands are assigned in b Transfer functionTransfer function

OUT(b) = def(b) ∪ (IN(b) – killed(b))OUT(b) = def(b) ∪ (IN(b) – killed(b)) Meet functionMeet function

IN(b) = IN(b) = )(

)(bpredp

pOUT

33

More Data Flow ProblemsMore Data Flow Problems

AVAIL EquationsAVAIL Equations

More data flow problemsMore data flow problems Reaching DefinitionReaching Definition LivenessLiveness

))()(_()()(_

)(_)(_)(

nkillednINAVAILndefnOUTAVAIL

pOUTAVAILnINAVAILnpredp

meet functionmeet function ∪∪ ∩∩

forwardforward reachingreaching

definitiondefinition availableavailable

expressionexpression

backwardbackward variablevariable livenessliveness

very busyvery busy

expressionexpression

34

Compiler Optimization

Local optimization DAG CSE Value numbering

Global optimization enabled by DFA Global CSE (AVAIL) Constant propagation (Def-Use) Dead code elimination (Use-Def)

Advanced topic: SSA

35

Perspective

Front end: essentially solved problem Middle end: domain-specific language Back end: new architecture Verifying compiler, reliability, security

36

Interesting Stuff We Skipped

Interprocedural analysis Alias (pointer) analysis Garbage collection

Check the literature reference in EaC

37

How will you use the knowledge?

As informed programmer As informed small language designer As informed hardware engineer As compiler writer

38

Informed Programmer

“Knowledge is power” Compiler is no longer a black box Know how compiler works

Implications Use of language features

Avoid those can cause problem Give compiler hints

Code optimization Don’t optimize prematurely Don’t write complicated code

Debugging Understand the compiled code

39

Solving Problem the Compiler Way

Solve problems from language/compiler perspective Implement simple language Extend language

40

Informed Hardware Engineer

Compiler support for programmable hardware pervasive computing new back-ends for new processors

Design new architectures what can compiler do and not do how to expose and use compiler to manage

hardware resources

41

Compiler Writer

Make a living by writing compilers!

Theory Algorithms Engineering

We have built: scanner parser AST tree builder, type checker register allocator instruction scheduler

Used compiler generation tools ANTLR, lex, yacc, etc

On track to jump intocompiler

development!

42

Final Remarks

Compiler construction Theory Implementation

How to use what you learned in this lecture? As informed programmer As informed small language designer As informed hardware engineer As compiler writer

… and live happily ever after