CS 4110 Programming Languages & Logics

Transcription

1 CS 4110 Programming Languages & Logics Lecture 38 Typed Assembly Language 30 November 2012

2 Schedule 2 Monday Typed Assembly Language Wednesday Polymorphism Stack Types Today Compilation Course Review

3 Certi ed Compilation 3 An automatic way to generate certi able low-level code Type safety implies memory, security properties

4 Certi ed Compilation 3 An automatic way to generate certi able low-level code Type safety implies memory, security properties Tiny Source language

5 Certi ed Compilation 3 An automatic way to generate certi able low-level code Type safety implies memory, security properties Tiny Source language Typed Assembly Language Compiler target

6 Certi ed Compilation 3 An automatic way to generate certi able low-level code Type safety implies memory, security properties Tiny Source language Typed Assembly Language Compiler target Optimized Typed Assembly Language Optimizer target

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

8 The Tiny Language 4 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)

9 Tiny Type System 5 Expressions Φ x : Φ(x)

10 Tiny Type System 5 Expressions Φ x : Φ(x) Φ f : Φ(f)

11 Tiny Type System 5 Expressions Φ x : Φ(x) Φ f : Φ(f) Φ n : int

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

13 Tiny Type System 5 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

14 Tiny Type System 5 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 : τ

15 Tiny Type System 5 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

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

17 Tiny Type System 6 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

18 Tiny Type System 6 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: Chat that fact is well typed

19 Type-preserving Compilation 7 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)

20 Type Translation 8 T [[ ]] maps Tiny types to TAL Types

21 Type Translation 8 T [[ ]] maps Tiny types to TAL Types Integers: T [[int]] = int

22 Type Translation 8 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 [[τ]]} {}

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

24 Expression Translation 9 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 nal 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

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

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

27 Expression Translation 10 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

28 Expression Translation 10 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

29 Expression Translation 11 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

30 Expression Translation 12 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

31 Declaration Translation 13 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

32 Program Translation 14 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

33 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 :: ρ] 15

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 :: ρ] 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 15

35 Compiler properties 16 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!

36 Optimizations Almost any compiler will produce better code than ours! (But how many compilers t 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 17

37 Tail-call Optimization 18 A crucial optimization for functional languages Applies when the nal 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!

38 Tail-call Optimization 19 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

39 Course Review

40

41 Mathematical Preliminaries & Operational Semantics

42 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics

43 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics λ-calculus

44 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics λ-calculus Preliminary Exam I

45 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics λ-calculus Preliminary Exam I Fall Break

46 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics Type Systems & Static Analysis λ-calculus Preliminary Exam I Fall Break

47 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics Type Systems & Static Analysis λ-calculus Preliminary Exam I Preliminary Exam II Fall Break

48 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics Type Systems & Static Analysis λ-calculus Preliminary Exam I Preliminary Exam II Advanced Topics Fall Break

49 21 Mathematical Preliminaries & Operational Semantics Denotational & Axiomatic Semantics Type Systems & Static Analysis λ-calculus Preliminary Exam I Preliminary Exam II Advanced Topics Fall Break Final Exam

50 Final Topics 22 Mathematical Preliminaries (inductive de nitions)

51 Final Topics 22 Mathematical Preliminaries (inductive de nitions) Semantics (operational, axiomatic, denotational)

52 Final Topics 22 Mathematical Preliminaries (inductive de nitions) Semantics (operational, axiomatic, denotational) λ-calculus (basics, encodings, extensions)

53 Final Topics 22 Mathematical Preliminaries (inductive de nitions) Semantics (operational, axiomatic, denotational) λ-calculus (basics, encodings, extensions) Type systems (simple, extensions, properties)

54 Final Topics 22 Mathematical Preliminaries (inductive de nitions) Semantics (operational, axiomatic, denotational) λ-calculus (basics, encodings, extensions) Type systems (simple, extensions, properties) Advanced topics (logic, security, concurrency, DSLs, TAL)

55 Final Topics 22 Mathematical Preliminaries (inductive de nitions) Semantics (operational, axiomatic, denotational) λ-calculus (basics, encodings, extensions) Type systems (simple, extensions, properties) Advanced topics (logic, security, concurrency, DSLs, TAL) Expect to solve probems just like the ones we ve seen throughout the course

56 Final Topics 22 Mathematical Preliminaries (inductive de nitions) Semantics (operational, axiomatic, denotational) λ-calculus (basics, encodings, extensions) Type systems (simple, extensions, properties) Advanced topics (logic, security, concurrency, DSLs, TAL) Expect to solve probems just like the ones we ve seen throughout the course and to apply the skills you ve acquired to new problems too!

57 Final Logistics 23 Date: Wednesday, December 12th Time: 7-9:30pm Where: Hollister 110 Practice: Available from Upson 4146 starting Monday Review: Sunday, December 9th?

58 Going further 24 Apply to attend ACM SIGPLAN PLMW

59 Going further 24 Apply to attend ACM SIGPLAN PLMW CS 6110 Advanced Programming Languages

60 Going further 24 Apply to attend ACM SIGPLAN PLMW CS 6110 Advanced Programming Languages CS 5114/6114 Network Programming Languages

61 Going further 24 Apply to attend ACM SIGPLAN PLMW CS 6110 Advanced Programming Languages CS 5114/6114 Network Programming Languages CS 7190 Seminar in Programming Languages

62 Going further 24 Apply to attend ACM SIGPLAN PLMW CS 6110 Advanced Programming Languages CS 5114/6114 Network Programming Languages CS 7190 Seminar in Programming Languages CS 4999 Independent Research

63 Going further 24 Apply to attend ACM SIGPLAN PLMW CS 6110 Advanced Programming Languages CS 5114/6114 Network Programming Languages CS 7190 Seminar in Programming Languages CS 4999 Independent Research Thank you, and stay in touch!