Compilers: The goal. Safe. e : ASM

Transcription

1 Compilers: The goal What s our goal with compilers? Take a high level language, turn it into a low level language In a semantics preserving way. e : ML Safe e : ASM 1

2 Compilers: The goal What s our goal with compilers? Take a high level language, turn it into a low level language In a semantics preserving way. e : ML The meaning of the program. Safe e : ASM 1

3 Compilers: The goal What s our goal with compilers? Take a high level language, turn it into a low level language In a semantics preserving way. e : ML The meaning of the program. Program in ASM corresponding e. Safe e : ASM 1

4 Compilers: The goal What s our goal with compilers? Take a high level language, turn it into a low level language In a semantics preserving way. e : ML The meaning of the program. Program in ASM corresponding e. Safe Some programs in ASM don t make sense in ML. 1 e : ASM

5 Why Compilers? Why do we need compilers? May have an interpreter for the language. But assembly runs faster. Doesn t necessarily need to compile to assembly. Can compile to C. In fact, each transformation is a compiler: Between intermediate forms. Easier to manipulate. In this lecture, we consider intermediate languges for functional languages. Such as Continuation Passing Style (CPS). Which makes control explicit. 2

6 Compilers: like onions Types, safety OCaml Core ML CPS {}}{ Intermediate code Danger ASM Speed (typically) 3

7 Compilers for functional languages What s hard about compiling functional languages? We re used to assembly language which is procedural We can t pass around functions. Or can we? Function pointers? Main idea To compile an OCaml program, find an equivalent C (like) program. 4

8 Compilers for functional languages What s hard about compiling functional languages? We re used to assembly language which is procedural We can t pass around functions. Or can we? Function pointers? Main idea To compile an OCaml program, find an equivalent C (like) program. 4

9 Functional languages have closures # l e t call me maybe x = l e t i = r e f x i n l e t i n c x = ( i :=! i + x ) ;! i i n i n c ; ; v a l call me maybe : i n t > i n t > i n t = <fun> # l e t my f = c all me maybe 4 2 ; ; v a l my f : i n t > i n t = <fun> # my f 1 2 ; ; : i n t = 54 Here, inc can touch i (not just its parameters!) Code + Data 5

10 What does OCaml have that C doesn t? We take OCaml as our functional language, and C as our procedural language. C readily translates into assembly. HOFs Closures (code with data) Garbage Collection Need to translate all these things into our low level language! 6

11 What does OCaml have that C doesn t? We take OCaml as our functional language, and C as our procedural language. C readily translates into assembly. HOFs as we see them in FP. HOFs Closures (code with data) Garbage Collection Not going to discuss. Need to translate all these things into our low level language! 6

12 What does OCaml have that C doesn t? We take OCaml as our functional language, and C as our procedural language. C readily translates into assembly. HOFs as we see them in FP. HOFs Closures (code with data) Garbage Collection Not going to discuss. Need to translate all these things into our low level language! 6

13 7 Intermediate stages for functional compilers To accomodate HOFs as return values, a slightly different set of intermediate forms is used: OCaml Core ML Simple desugaring to λ-ish calculs Continuation passing style (CPS) Transformation from λ to CPS Optimization of CPS Clever tricks, β reduction, for example. Closure conversion Make all functions top level: take nested functions and pull them to the top (as in C). Register allocation, assembly language, etc...

14 Where to begin? OCaml Core ML CNF ASM 8

15 Starting point: Core ML We start with a language called Core ML: Most of OCaml compiles into it simply enough. Very few operators. Maintains real semantic content. Cosmetic transformations: Desugar control (if/else) Lambdas Pattern matching Exceptions etc... 9

16 Introduce helper functions l e t x = 23 i n i f ( x < 0) then x e l s e x fif b e 1 e 2 is a primitive function which, if b computes to true, computes e 1, and if not, computes e 2. ( λ x. f i f ( x < 0) ( x ) x ) 23 10

17 Desugaring let as λ If you stare at it properly, you can see that let is simply λ placed at the appropriate place! l e t x 1 = e 1 i n l e t x 2 = e 2 i n... i n e (λ x 1 (λ x 2... e ) e n... ) e 1 11

18 Want to compile pattern matching to set of more primitive operations. Core idea: remember the order of matches is important. Reason based on decision trees. Compile to a chain of IFs. 12 Pattern matching match a with ( f a l s e, n i l ) > n i l ( true, w) > w ( f a l s e, x : : n i l ) > x : : x : : n i l ( f a l s e, y : : z ) > z l e t (a 1,a 2 ) = a i n i f (a 1 = f a l s e && a 2 = n i l ) then n i l e l s e e l s e i f (a 1 = t r u e ) then a 2 e l s e...

19 Want to compile pattern matching to set of more primitive operations. Core idea: remember the order of matches is important. Reason based on decision trees. Compile to a chain of IFs. This is only one way to do it. There exist optimized methods to produce minimal decision trees. 12 Pattern matching match a with ( f a l s e, n i l ) > n i l ( true, w) > w ( f a l s e, x : : n i l ) > x : : x : : n i l ( f a l s e, y : : z ) > z l e t (a 1,a 2 ) = a i n i f (a 1 = f a l s e && a 2 = n i l ) then n i l e l s e e l s e i f (a 1 = t r u e ) then a 2 e l s e...

20 Want to compile pattern matching to set of more primitive operations. Core idea: remember the order of matches is important. Reason based on decision trees. Compile to a chain of IFs. This is only one way to do it. There exist optimized methods to produce minimal decision trees. 12 Pattern matching match a with ( f a l s e, n i l ) > n i l ( true, w) > w ( f a l s e, x : : n i l ) > x : : x : : n i l ( f a l s e, y : : z ) > z Needs desugaring l e t (a 1,a 2 ) = a i n i f (a 1 = f a l s e && a 2 = n i l ) then n i l e l s e e l s e i f (a 1 = t r u e ) then a 2 e l s e...

21 Core ML type name = Name of s t r i n g I n t of i n t type c o n s t a n t = { name : name ; c o n s t r : b o o l ; a r i t y : i n t } type v a r = s t r i n g type e x p r = Var of v a r Const of c o n s t a n t Fun of v a r e x p r App of e x p r e x p r 13

22 Current state of things OCaml Core ML CNF ASM 14

23 Continuations: where to go next The next stage in the compiler uses continuations. It s best to show the idea of continuations by example... l e t a d d o n e s u b t r a c t t w o x = (λ k x. k ( x + 1 ) ) (λ y. ( y 2 ) ) Continuations continue the computation. Once you compute a piece of the result, you invoke the continuation, and it carries it the rest of the way. 15

24 16 Continuation passing style In Continuation Passing Style (CPS): every function takes an extra continuation argument. When functions compute their result, they hand it to the continuation argument. Corrolary: No function ever returns to its caller! We aren t building up stack frames! l e t pyth x y k = ( k x x (λ x 2. ( k y y (λ y 2. (+ k x 2 y 2 (λ x2py2. (sqrt k x2py2 k ) ) ) ) ) ) ) ) A nice consequence: because functions never return, instead of CALLing them, we can simply JUMP to them. In a way, writing in CPS linearizes our program.

25 Another example... l e t f a c t o r i a l n = i f n=0 then 1 e l s e n f a c t o r i a l ( n 1) CPS( ) l e t f a c t o r i a l n k = = k n 0 (λ b. i f b then ( k 1) e l s e ( k n 1 (λ nm1. ( f a c t o r i a l nm1 (λ f ( k n f k ) ) ) ) ) This continuation keeps growing larger and larger every time! 17

26 Contrast with tail recursive version... l e t f a c t o r i a l n = f h e l p e r n 1 18 l e t f h e l p e r n a = i f n = 0 then a e l s e f h e l p e r ( n 1) ( n a ) CPS( ) l e t f a c t o r i a l n k = f h e l p e r n 1 k l e t f h e l p e r n a k = = k n 0 (λ b. i f b ( k a ) e l s e ( k n 1 (λ nm1. ( k n a (λ nta. ( f aux nm1 nta k ) ) ) ) ) )

27 Kicking off the computation Now that we have this lingering continuation hanging everywhere, how do we start the computation? l e t pyth x y k = ( k x x (λ x 2. ( k y y (λ y 2. (+ k x 2 y 2 (λ x2py2. (sqrt k x2py2 k ) ) ) ) ) ) ) ) pyth 1 2 (??? ) How about: λx.x or λx. "print x"? In the general case, this corresponds to where you stop the computation. (Delimited continuations let you play with this idea more.) 19

28 Transforming to CPS We can translate all of the constructs in Core ML into CPS using a simple transform: The CPS Transform Flip each computation point inside out so that we can explicitly see where to go next. l e t s q u a r e = λ x k. k x x k We attempt to linearize the computation, so that we can take the atomic pieces, build up results, and then pass them off to the rest of the computation (the continuation) 20

29 CPS( ) CPS c = λk.(k c) CPS x = λk.(k x) CPS λx.e = λk x. CPS(e) CPS e e 1 = λk. CPS e 1 (λk 1.CPS e ) 21

30 Example of using the CPS( ) transform i n c (2 + 3) App ( Const ( i n c ), App ( Core( ) App ( Const ( + ), Const ( 2 ) ), 3 ) ) CPS( ) (λ k. k 3 ( ( λ k x. k (+ 2 x ) ) (λ k y. k ( i n c y ) ) 22

31 Generating low level code from CPS OCaml Core ML CNF ASM 23

32 Generating low level code from CPS OCaml Core ML We now have code in CPS, but how can we generate low level code from it? First idea, interpret APPLYs as jumps. CNF ASM 23

33 Closure Conversion (Lambda Lifting) C doesn t have closures. If we want to compile our CPS to a format with only top level functions, we need (the equivalent of) closures. Basic idea: look at the function, assume an extra environment table with which you can look up variables over which the function closes. 24

34 Conclusion Compilers for functional languages work similarly in spirit to those for procedural languages. In both cases we slowly work down to some lower level implementation while preserving the semantics. But most real machines don t have features amenable to the implemenation of functional languges. To solve this problem, we apply various tricks linearize the code and make it look like C 25