ICS 142 Klefstad

Code Generation

Outline Introduction Code Generation Issues Basic Blocks and Flow Graphs Next-Use Information Register Allocation and Assignment The DAG Representation for Basic Blocks Generating Code from Expression Trees Generating Code from DAGs

Introduction

typical structure of the compiler

-source-code -->
  FRONT-END - intermediate-code -->
  CODE-OPTIMIZER - intermediate-code -->
  CODE-GENERATOR - target-code -->

code generation is extremely machine specific, but can often be described in a machine independent manner, EG GNU C
machines are often idiosyncratic
- EG constraints on register and memory operations

Code Generation Issues

the input to the code generator
- DAG, expression tree, three address, or postfix
the target program
- absolute binary, relocatable binary, or symbolic assembly
- see 9.2 page 519 of text for example
instruction selection is affected by
- orthogonality of the instruction set
- instruction speeds
  - shift N is faster than multiply by 2**N
  - "clr R0" may be faster than "move 0, R0"
- machine idioms
  - EG incr(x) may be faster than x = x + 1

register allocation
- register reference is MUCH faster than memory reference
  - EG
- instructions using registers may be shorter
- often two address instructions require a register for (at least) one operand, especially on RISC machines
- some instructions require register pairs (multiply and divide), this complicates code generation and optimization
choice of expression evaluation order
- some orders require fewer registers, EG a + b * c
approaches
- simple, dumb, small, and fast
- data-flow analysis: complicated, smart, big, and slow

Basic Blocks and Flow Graphs

a definition of a variable
- any assignment to that variable
a use of a variable
- any reference to the value in that variable
a variable is live at a point
- its value is used after that point
basic block
- a sequence of statements where flow enters the top and leaves the end, IE one entry, one exit

a flow graph is a graph
- nodes represent computations (typically basic blocks)
- edges represent flow of control
loops
- one unique entry, called the loop header
- nodes within the loop are strongly connected, IE any node in the loop can potentially reach any other node
- inner loop contains no other loops
- programs spend most of their time in loops, therefore, it pays to optimize loops

Basic Block construction algorithm on page 529

FOR (result=0, i=1; i<10; i++)
  result += a[i] * b[i];
1   result := 0
2   i := 1
3   t1 := 4 * i -- 4 is the element size of a
4   t2 := a[t1]
5   t3 := 4 * i -- 4 is the element size of b
6   t4 := b[t3]
7   t5 := t2 * t4
8   t6 := result + t5
9   result := t6
10  t7 := i+1
11  i := t7
12  IF i < 10 GOTO 3

Next-Use Information

useful for optimization, EG can detect dead code
make a backwards pass over each basic block, stores info in symbol table
for each instruction i of the form: X := Y op Z
- set X to not live and no next use
- set y and z to live and next use to i

Register Allocation and Assignment

global register allocation
- assigning variables to registers across basic block boundaries
- however, may tie up too many register
usage counts
- sum up the references and allocate registers to most frequently referenced variables, according to some heuristic
```
FOR block B IN loop L LOOP
  count += use(x, B) + 2*live(x, B);
END LOOP;
```
- same idea applies to outer loops, but after inner loop has been assigned registers
by graph coloring
- a register-interference graph is generated for each procedure
- graph coloring assigns a set of registers to temporaries to minimize spilling (dumping the value of a register to memory)

The DAG Representation for Basic Blocks

not a flow graph
- does not contain control flow information
- does contain dependency information, IE parents depend on children
similar to DAGs for expression trees
- leaves are labeled by unique identifiers, variable names or constants, and represent initial values of names
- interior nodes represent operations
- nodes may be labeled by identifiers which have the value computed by that node
useful for
- detecting common subexpressions
- provides data flow information useful for optimizations
- allows elimination of useless or dead statements

Constructing a DAG

FOR (result=0, i=1; i<10; i++)
  result += a[i] * b[i];
3   t1 := SIZEOF *a * i
4   t2 := a[t1]
5   t3 := SIZEOF *b * i
6   t4 := b[t3]
7   t5 := t2 * t4
8   t6 := result + t5
9   result := t6
10  t7 := i + 1
11  i := t7
12  IF i < 10 GOTO 3

\input dag.tex \relax \box \graph

Generating Code from Expression Trees

uses a 2-pass technique called Sethi-Ullman Numbering (see page 561-4)
produces provably optimal register usage for expression trees that have no common subexpressions
evaluating operand subtree using most registers first, then other next
in case of tie, evaluate left operand first (for two address instruction)

Generating code from DAGs

rearrange the order to minimize register usage (see page 560)
since generating optimal code from DAGs is NP-hard, we use heuristics
use a variant of topological sorting
common subexpressions can be treated as separate trees, replace reference to subexpression with temporary containing the value

Code Generator Generators

input is a set of rewriting rules
used extensively in the GNU compiler to enhance portability
See example on page 575 of the text
Also see the GNU C compiler source code