The Semantic Soundness of a Type System for

Interprocedural Register Allocation and Constructor

Registration

Torben Amtoft Kansas State University

joint work with Robert Muller, Boston College

Semantics Seminar, Northeastern University, May 28, 2003

Typed Compilation of ML-like Languages

let val a : int = 3 val b : int = 4 fun f(x : int) = x + a * b fun g(x : int) = x + bin (if test then f else g) @ 343end

Defunctionalization let type t1 = {a : int, b : int} type t2 = {b : int} type t3 = (t1 + t2) fun apply1(h : t3, x : int) : t3 * int int = case h of r : t1 => let val a : int = #a(r) val b : int = #b(r) val c : int = a * b val d : int = x + c in d end r : t2 => let val b : int = #b(r) val c : int = x + b in c end

. . .

Defunctionalization

…val a : int = 3val b : int = 4val c : t1 = {a = a, b = b}val d : t2 = {b = b}val e: int = 343val h : t3 = if test then inj(1,c)t3 else inj(2,d)t3

in apply1(h, e)end

Types with Storage Annotations

let type t1 = {a : int H, b : int H} r1 type t2 = {a : int H, b : int H} H type t3 = {b : int H} r2 type t4 = {b : int H} H type t5 = (t2 +H t4) r3 fun apply1(h : t5, x : int r4) : int r5 = case h of r : t1 => let val a : int r6 = #a(r) val b : int r7 = #b(r) val c : int r8 = a * b val d : int r5 = x + c in d end r : t3 => let val b : int r9 = #b(r) val c : int r5 = x + b in c end

. . .

Types with Storage Annotations

…val a : int r1 = 3val b : int r2 = 4val c : t1 = {a = a, b = b}val d : t3 = {b = b}val e: int r4 = 343val h : t5 = if test then inj(1,c)t5 else inj(2,d)t5

in apply1(h, e)end

type t = {a : int H, b : {c : int H, d : int H} H} r1val v : t = {a = 3, b = {c = 4, d = 3}}type t = {a : int H, b : {c : int H, d : int H} H} r1val v : t = {a = 3, b = {c = 4, d = 3}}

3HeapRegister

4

3

r1

r2

r3

r4

Standard Record Representation

type t = {a : int r1, b : {c : int H, d : int H} r3} oval v : t = {a = 3, b = {c = 4, d = 3}}type t = {a : int r1, b : {c : int H, d : int H} r3} oval v : t = {a = 3, b = {c = 4, d = 3}}

3HeapRegister

4

3

r1

r2

r3

r4

Record Registration

type t = {a : int r1, b : {c : int r4, d : int r3} o} oval v : t = {a = 3, b = {c = 4, d = 3}}type t = {a : int r1, b : {c : int r4, d : int r3} o} oval v : t = {a = 3, b = {c = 4, d = 3}}

3HeapRegister

3

4

r1

r2

r3

r4

Complete Registration

type t1 = (int H +H int H) Htype t2 = (int H +H t1) r1val v : t2 = inj(2,inj(1,25)t1)t2

type t1 = (int H +H int H) Htype t2 = (int H +H t1) r1val v : t2 = inj(2,inj(1,25)t1)t2

2HeapRegister

1

25

r1

r2

r3

r4

Standard Variant Representation

type t1 = (int H +H int H) r3type t2 = (int r2 +r1 t1) oval v : t2 = inj(2,inj(1,25)t1)t2

type t1 = (int H +H int H) r3type t2 = (int r2 +r1 t1) oval v : t2 = inj(2,inj(1,25)t1)t2

2HeapRegister

1

25

r1

r2

r3

r4

Variant Registration

type t1 = (int r2 +r4 int r1) otype t2 = (int r3 +r1 t1) oval v : t2 = inj(2,inj(1,25)t1)t2

type t1 = (int r2 +r4 int r1) otype t2 = (int r3 +r1 t1) oval v : t2 = inj(2,inj(1,25)t1)t2

2HeapRegister

25

1

r1

r2

r3

r4

Complete Variant Registration

Closure Registrationlet type t1 = {a : int r1, b : int r2} o type t2 = {b : int r2} o type t3 = (t1 +r3 t2) o fun apply1(h : t3, x : int r4) : int r5 = case h of r : t1 => let val a : int r1 = #a(r) // no-op val b : int r2 = #b(r) // no-op val c : int r6 = a * b val d : int r5 = x + c in d end r : t2 => let val b : int r2 = #b(r) // no-op val c : int r5 = x + b in c end

. . .

Closure Registration

…val a : int r1 = 3val b : int r2 = 4val c : t1 = {a = a, b = b} // no-opval d : t3 = {b = b} // no-opval e: int r4 = 343val h : t3 = if test then inj(1,c)t3 else inj(2,d)t3

in apply1(h, e)end

What we have Developed

1. A storage annotation type system

2. A typed SECD-like abstract machine

3. An annotation inference algorithmOur system works on monomorphized

whole-programs in defunctionalized A-nf.

Type System

Syntax:a ::= ri | H | o ;

annotations ::= t a

t ::= unit | int | * | +a ft ::= * A

e ::= …

Judgments: e

Kill Set

Example: Product Types

E |- (x1,x2) : (t1 a’1 * t2 a’2) a ! {a}

WFat((t1 a’1 * t2 a’2) a)E |- x1 : t1 a1; E |- x2 : t2 a2; a’i in {ai,H}

E |- i(x) : ti a’i ! {a’i} - {ai}

WFat(ti a’i)E |- x : (t1 a1 * t2 a2) a; ai in {a’i,H}

RecursionInterference

and theStack

let fun apply1(fact : unit, n : int) : int = let val a : int = 1 in ifzero n then a else let val b : int = n – a val c : int = apply1(fact,b) in let val d : int = c * n in d end end end val e : int = 4 val fact : unit = {}in apply1(fact,e) end

Defunctionalized Factorial

let fun apply1(fact : unit o, n : int r1) : int r2 = let val a : int r2 = 1 in ifzero n then a else let val b : int r3 = n – a in letcall{r1} val c : int r2 = apply1(fact,br3) in let val d : int r2 = c * nr1 in d end end end end val e : int r1 = 6 val fact : unit o = {}in apply1(fact,e) end

Defunctionalized Factorial

move r1,r3

Abstract Machine

Continuations:

K ::= stop | <x,a,{vi

ri},e,E,W,K>

Value Environment

Type Environment

Savedvalues

Abstract Machine

Machine States:

Z ::= <e, R, H, E, W, K>

Register File

Heap

Abstract Machine

Machine States:

Z ::= <e, R, H, E, W, K>

Transition Relation:

Z Z’

Properties of the System

1. Well-Typedness Preservation: WT(Z) and Z Z’ implies WT(Z’).

2. Progress: If WT(Z) then either Z is final or there exists Z’ such that Z Z’.

Annotation Inference Algorithm

Annotate(E, ue) = (e, , q, C)

Set expression

Typed but unannotated expression

Constraint Set

Expression with annotation variables

Annotated type scheme

What our System Does1. Interprocedural Virtual Register

Allocation

2. Record and Variant Registration• Function Argument Registration• Multiple-value Return

3. Customized Calling Conventions

4. Space-Efficient Tail-Calls

5. Type Safety

What we don’t Do1. Solve the Constraints

2. Physical Register Allocation

3. Heap Management

4. Empirical Analysis of Allocation Heuristics

5. Separate Compilation

Related Work

1. J. Agat 1997, 1998.

2. Morrisett et. al., 1998, 1999,…

3. Crary 2003

4. Petersen et. al., 2003

Conclusion

1. We have developed a type system that may be useful in performing reliable and efficient register allocation.

2. We intend to integrate it with a physical register allocation system.

3. We intend to study its performance.

Implementation StatusDone:1. Translation, annotation and constraint

generation (Brendan Connell)

2. Abstract Machine (Dan Allen)

Not Done:1. Constraint solving (Dan Allen)

2. Physical Register Allocation