CS 4110 Programming Languages & Logics. Lecture 35 Typed Assembly Language

Transcription

1 CS 4110 Programming Languages & Logics Lecture 35 Typed Assembly Language 1 December 2014

2 Announcements 2 Foster Office Hours today 4-5pm Optional Homework 10 out Final practice problems out this week

3 Schedule 3 One and a half weeks ago... Typed Assembly Language Last Monday Polymorphism Stack Types Today Compilation

4 Certified Compilation 4 An automatic way to generate certifiable low-level code Type safety implies memory, security properties

5 Certified Compilation 4 An automatic way to generate certifiable low-level code Type safety implies memory, security properties Tiny Source language

6 Certified Compilation 4 An automatic way to generate certifiable low-level code Type safety implies memory, security properties Tiny Source language Typed Assembly Language Compiler target

7 Certified Compilation 4 An automatic way to generate certifiable low-level code Type safety implies memory, security properties Tiny Source language Typed Assembly Language Compiler target Optimized Typed Assembly Language Optimizer target

8 The Tiny Language 5 Features Integer expressions Conditionals Recursive functions Function pointers (but no closures) A strong, static type system

9 The Tiny Language 5 Features Integer expressions Conditionals Recursive functions Function pointers (but no closures) A strong, static type system Example program letrec fun fact (n:int) : int = if n = 0 then 1 else n * fact (n 1) in fact (42)

10 Tiny Type System 6 Expressions Φ x : Φ(x)

11 Tiny Type System 6 Expressions Φ x : Φ(x) Φ f : Φ(f)

12 Tiny Type System 6 Expressions Φ x : Φ(x) Φ f : Φ(f) Φ n : int

13 Tiny Type System 6 Expressions Φ x : Φ(x) Φ f : Φ(f) Φ n : int Φ e 1 : int Φ e 2 : int Φ e 1 + e 2 : int

14 Tiny Type System 6 Expressions Φ x : Φ(x) Φ f : Φ(f) Φ n : int Φ e 1 : int Φ e 1 + e 2 : int Φ e 2 : int Φ e 1 : τ 1 τ 2 Φ e 2 : τ 1 Φ e 1 e 2 : τ 2

15 Tiny Type System 6 Expressions Φ x : Φ(x) Φ f : Φ(f) Φ n : int Φ e 1 : int Φ e 1 + e 2 : int Φ e 2 : int Φ e 1 : τ 1 τ 2 Φ e 2 : τ 1 Φ e 1 e 2 : τ 2 Φ e 1 : int Φ e 2 : τ Φ e 3 : τ Φ if e 1 = 0 then e 2 else e 3 : τ

16 Tiny Type System 6 Expressions Φ x : Φ(x) Φ f : Φ(f) Φ n : int Φ e 1 : int Φ e 1 + e 2 : int Φ e 2 : int Φ e 1 : τ 1 τ 2 Φ e 2 : τ 1 Φ e 1 e 2 : τ 2 Φ e 1 : int Φ e 2 : τ Φ e 3 : τ Φ if e 1 = 0 then e 2 else e 3 : τ Φ e 1 : τ 1 Φ, x : τ 1 e 2 : τ 2 Φ let x = e 1 in e 2 : τ 1

17 Tiny Type System 7 Declarations Φ, x : τ 1 e : τ 2 Φ fun f(x : τ 1 ) : τ 2 = e : (f : τ 1 τ 2 )

18 Tiny Type System 7 Declarations Φ, x : τ 1 e : τ 2 Φ fun f(x : τ 1 ) : τ 2 = e : (f : τ 1 τ 2 ) Programs Φ = f 1 : τ 11 τ 12,..., f k : τ k1 τ k2 Φ d i : (f i : τ i1 τ i2 ) Φ e : int letrec d 1 d k in e

19 Tiny Type System 7 Declarations Φ, x : τ 1 e : τ 2 Φ fun f(x : τ 1 ) : τ 2 = e : (f : τ 1 τ 2 ) Programs Φ = f 1 : τ 11 τ 12,..., f k : τ k1 τ k2 Φ d i : (f i : τ i1 τ i2 ) Φ e : int letrec d 1 d k in e Exercise: Check that fact is well typed

20 Type-preserving Compilation 8 Most compilers consist of a series of transformations In our compiler, each step will propagate types A transformation consists of two sub-translations: From source types to target types From source terms to target terms After each step, can typecheck the intermediate output code to detect errors in the compiler Key correctness property will be that transformations preserve types (as well as semantics)

21 Type Translation 9 T [[ ]] maps Tiny types to TAL Types

22 Type Translation 9 T [[ ]] maps Tiny types to TAL Types Integers: T [[int]] = int

23 Type Translation 9 T [[ ]] maps Tiny types to TAL Types Integers: T [[int]] = int Functions: Caller pushes argument and return address on stack Callee pops the return address and argument and places result in ra T [[τ 1 τ 2 ]] = ρ.{sp : K[[τ 2, ρ]] :: T [[τ 1 ]] :: ρ} {} where K[[τ, σ]] = {sp : σ, r a : T [[τ]]} {} K[[τ]] = {r a : T [[τ]]} {}

24 Expression Translation 10 E[[ ]] maps Tiny expressions (really typing derivations) to labeled code blocks

25 Expression Translation 10 E[[ ]] maps Tiny expressions (really typing derivations) to labeled code blocks We use the stack extensively: To evaluate an expression, evaluate subexpressions then push them onto the stack Return final value in ra M maps expression variables to stack offsets I(M) increments the offset associated with each variable in M Overall, uses just two registers, r a and r t, and the stack Shape of the translation is E[[e]] M,σ = J, where J is a sequence of typed, labeled blocks. Write L f for the TAL label of function f

26 Expression Translation 11 Expression variables E[[x]] M,σ = sld r a, M(x)

27 Expression Translation 11 Expression variables E[[x]] M,σ = sld r a, M(x) Function variables E[[f]] M,σ = mov r a, L f

28 Expression Translation 11 Expression variables E[[x]] M,σ = sld r a, M(x) Function variables E[[f]] M,σ = mov r a, L f Integers E[[n]] M,σ = mov r a, n

29 Expression Translation 11 Expression variables E[[x]] M,σ = sld r a, M(x) Function variables E[[f]] M,σ = mov r a, L f Addition E[[e 1 + e 2 ]] M,σ = E[[e 1 ]] M,σ push r a E[[e 2 ]] I(M),int :: σ pop r t add r a, r t, r a Integers E[[n]] M,σ = mov r a, n

30 Expression Translation 12 Application E[[e 1 e 2 ]] M,σ = E[[e 1 ]] M,σ push r a E[[e 2 ]] I(M),T [[τ1 τ 2 ]] :: σ pop r t push r a push L r [ρ] jmp r t [σ] L r : ρ. K[[τ 2, σ]] where Φ e 1 : τ 1 τ 2 and L r fresh

31 Expression Translation 13 Conditional E[[if e 1 = 0 then e 2 else e 3 ]] M,σ = E[[e 1 ]] M,σ bneq r a, L else [ρ] E[[e 2 ]] M,σ jmp L end [ρ] L else : ρ.{sp : σ} {} E[[e 3 ]] M,σ jmp L end [ρ] L end : ρ.k[[τ, σ]] where Φ e 2 : τ and Φ e 2 : τ and L else and L end fresh

32 Declaration Translation 14 Function F[[fun f (x : τ 1 ) : τ 2 = e]] = L f : T [[τ 1 τ 2 ]] E[[e 2 ]] x := 2,K[[τ2,ρ]] :: T [[τ 1 ]] :: ρ pop r t sfree 1 jmp r t

33 Program Translation 15 Program P[[letrec d 1 d k in e]] = F[[d 1 ]]. F[[d k ]] L main : ρ.{sp : K[[int, ρ]] :: ρ} {} E[[e]],K[[int,ρ]] :: ρ pop r t jmp r t To run the program, push return address on stack and jump to L main Result is returned in r a

34 Factorial L fact : ρ. {sp : K[[int]] :: int :: ρ} sld r a,2 bneq r a,l else [ρ] mov r a,1 jmp L end L else : ρ. {sp : K[[int]] :: int :: ρ} sld r a,2 push r a mov r a,l fact push r a sld r a,4 push r a mov r a,1 pop r t sub r a,r t,r a pop r t push L r [ρ] jmp r t [int :: K[[int, ρ]] :: int :: ρ] 16

35 Factorial L fact : ρ. {sp : K[[int]] :: int :: ρ} sld r a,2 bneq r a,l else [ρ] mov r a,1 jmp L end L else : ρ. {sp : K[[int]] :: int :: ρ} sld r a,2 push r a mov r a,l fact push r a sld r a,4 push r a mov r a,1 pop r t sub r a,r t,r a pop r t push L r [ρ] jmp r t [int :: K[[int, ρ]] :: int :: ρ] L r : ρ. {sp : K[[int]] :: int :: ρ, r a : int} pop r t mul r a,r t,r t jmp L end [ρ] L end : ρ. {sp : K[[int]] :: int :: ρ, r a : int} pop r t sfree 1 jmp r t 16

36 Compiler properties 17 Theorem If P then there exists Ψ such that P[[P]] : Ψ Proof by induction on P... Main idea: We don t have to trust the compiler because we can typecheck the assembly code emitted as output!

37 Optimizations Almost any compiler will produce better code than ours! (But how many compilers fit on four slides?) The type system makes it possible to implement many standard optimizations to generate better code: Instruction selection and scheduling Register allocation Common subexpression elimination Redundant load/store elimination Strength reduction Loop-invariant removal Tail-calls and others... Types do not interfere with the most common optimizations 18

38 Tail-call Optimization 19 A crucial optimization for functional languages Applies when the final operation in a function f is a call to another function g Instead of having f push the return address onto the stack and engage in the normal calling sequence, f pops all of its temporary values, jumps directly to g and never returns!

39 Tail-call Optimization 20 Unoptimized code L f : ρ. {sp : K[[τ, ρ]] :: τ f :: ρ, r a : τ g } {} salloc 2 % setup stack frame sst L r % push return address sst r a,2 % push argument jmp L g [τ :: τ f :: ρ] L r : ρ. {sp : τ :: τ f :: ρ, r a : τ} {} pop r t % pop return address sfree 1 % discard f s argument jmp r t % return Optimized code L f : ρ. {sp : K[[τ, ρ]] :: τ f :: ρ, r a : τ g } {} sst r a,2 jmp L g [ρ] % g returns to f s caller