1. STAL David Walker (joint work with Karl Crary, Neal Glew and Greg Morrisett) http://www.cs.cornell.edu/home/walker/talnet/tal.html

2. Dave Walker2 Compiling With Typed ILs [Flint, GHC, TIL(T),...] TermsTypes Source IL Machine

3. Dave Walker3 TIL Advantages Security (JVM) Optimization (unboxing) Proofs of Correctness (closure conversion) Semantics (Harper & Stone) Debugging (TIL) Explicit Compiler Invariants

4. Dave Walker4 The Gap Machine TermsTypes Source IL Register Allocation Instruction Selection Instruction Scheduling Low level Optimization

5. Dave Walker5 TAL Advantages Security, Optimization, Proofs Debugging, Semantics, and Invariants TermsTypes Source IL Machine

6. Dave Walker6 Outline Front-end: What is TAL? Middle-end: Adding Stacks Back-end: Typed Code Generation

7. Dave Walker7 TAL Instructions standard RISC: mov, ld, st, add, jmp, beq … few macros: malloc r1[  1, …,  n ] type annotations: unpack [ , r1], r1

8. Dave Walker8 TAL Types ints and other base types tuples with initialization flags: polymorphic code types: existential types:  [  ].{ r1: , r2:int, r3:{r1:  } } .

9. Dave Walker9 TAL Example: Sum % sum: r1 + 1 + 2 +... + r2 % r1: Accumulator % r2: Counter % r3: Continuation sum: { r1:int, r2:int, r3:{r1:int} } beq r2, r3% if r2 = 0, jump to cont. add r1, r2% r1 := r1 + r2 sub r2, 1% decrement counter jmp sum% iterate loop

10. Dave Walker10 TAL Example: Mkpair mkpair: { r1:int, r2:{r1: } } malloc r3[int, int] % r3: st r3[0], r1 % r3: st r3[1], r1 % r3: mov r1, r3 jmp r2 % jump to cont. call site : { r2:{r1: }, r5: } mov r1, 17 jmp mkpair

11. Dave Walker11 Heap-Allocated Environments mkpair:  [  ].{ r1:int, r2:{r1:, r env :  }, r env :  } call site : malloc r env [  3,...,  n ] st r env [0], r3... st r env [n], rn jmp mkpair[ ] r env

12. Dave Walker12 Stack- vs Heap-Allocation simple, efficient 1st- class continuations better environment sharing unified memory management better locality benefits from hardware bias GC-independent HeapsStacks

13. Dave Walker13 STAL new dedicated register: sp stack types: instructions: uninitialized stack slots have nonsense type (ns)  :=  | nil |  ::  salloc n | sfree n | sld r, sp[i] | sst sp[i], r

14. Dave Walker14 STAL Example: Mkpair mkpair:  [  ].{ sp: , r1:int, r2:{sp:int::int::  } } salloc 2% sp: ns::ns::  sst sp[0], r1% sp: int::ns::  sst sp[1], r1% sp: int::int::  jmp r2% jump to cont.

15. Dave Walker15 STAL Example: Sum % accumulator: on stack % counter: in r1 % return address: in r2 sum:  [  ].{ sp:int:: , r1:int, r2:{sp:int::  } } beq r1, r2% if r1 = 0, jump to cont. sld r2, sp[0]% load from stack add r2, r1% r2 := r2 + r1 sst sp[0], r2% store to stack sub r1, 1% decrement counter jmp sum[  ]% iterate loop

16. Dave Walker16 Sum Example Cont’d call site :  [  ’].{ sp:  ’, r1:int, r2:{sp:int::  2 ::... ::  n ::  ’} } salloc n sst sp[1], r2... sst sp[k], rn % k = n-1 sst sp[0], 0 % accumulator jmp sum[  2 ::... ::  n ::  ’] sum:  [  ].{ sp:int:: , r1:int, r2:{sp:int::  } } sp : int :  2...... ’’  :  n

17. Dave Walker17 Key Points Code types specify stack state Code can be stack-polymorphic Abstract stack type variables protect the caller’s stack from the callee Stack-based code passes continuations

18. Dave Walker18 Stack-allocated activation records: Heap-allocated activation records: Stack- vs. Heap-Allocated Activation Records  [  ].{ r1:int, r2:{r1:int, r env :  }, r env :  }  [  ].{ r1:int, r2:{r1:int, sp:  }, sp:  } r env sp

19. Dave Walker19 Caller boxes continuation: Multiple continuations: Calling Conventions  [  ].{ r1:int, r2: }  [ ,  ].{ r1:int, r ret :, r exn : }

20. Dave Walker20 More Calling Conventions Closed function type: Stack-Based Calling Conventions: C:  [  ].{ sp:{r1:int, sp:char::  }::char::  } Pascal/Win32:  [  ].{ sp:{r1:int, sp:  }::char::  } KML:... char  int

21. Dave Walker21 The Paper Simple Stacks Compound Stacks –sp :  1   ::  2 Restricted Stack Pointers –r3 : ptr(  ::  2 ) Efficient exceptions, displays,... Not &

22. Dave Walker22 Implementation KML F-omega++ STALx86 Scheme-- Popcorn Additional Contributers: Chris Hawblitzel Fred Smith Stephanie Weirich Steve Zdancewic

23. Dave Walker23 Summary we can type both stacks and heaps types can specify code generation invariants types explain connections between different compilation strategies

24. Dave Walker24 Stack Allocated Data 11 sp 22 17 5 -4 r3  [  1,  2 ]. {sp: (int::  1 )  (int::int::  2 ), r3: ptr(int::int::  2 )}

25. Dave Walker25 PCC vs TAL PCC 1st-order predicate logic LF type checking of embedded proofs Low-level abstractions (addr, read, write,...) TAL Higher-order type theory Type checking of assembly language objects directly High-level abstractions ( , ,,...) Use logic to build enforceable abstractions on top of machine language Admit almost all optimizations