1 / 18

A Novel Calculational Approach to Compiler Construction from High-Level Semantics

This talk presents an innovative method for deriving compilers from high-level semantics using straightforward techniques formalized in Coq. It introduces a three-step process involving stack manipulation, continuation passing style, and defunctionalization to effectively handle complex features such as state, variable binding, and loops. The approach is purely calculational, ensuring compilers are correct by construction and adaptable to various language constructs. Future work includes exploring register-based machines and mechanical assistance for broader applications in compiler technology.

jane-cunningham
Télécharger la présentation

A Novel Calculational Approach to Compiler Construction from High-Level Semantics

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. How To Make Sausages

  2. How To Make Compilers? language compiler

  3. This Talk • A new approach to the problem of calculating compilers from high-level semantics; • Only requires simple techniques, and all the calculations have been formalised in Coq; • Scales to exceptions, state, variable binding, loops, non-determinism, interrupts, etc.

  4. Arithmetic Expressions Syntax: data Expr = Val Int | Add Expr Expr Semantics: eval :: Expr  Int eval (Val n) = n eval (Add x y) = eval x + eval y

  5. Step 1 – Stacks Make the manipulation of arguments explicit by transforming the semantics to use a stack. Aim: define a new semantics evalS :: Expr  Stack  Stack such that Stack = [Int] evalS e s = eval e : s

  6. Case for addition: evalS (Add x y) s = add (n:m:s) = m+n : s eval (Add x y) : s = (eval x + eval y) : s = add (eval y : eval x : s) = add (eval y : evalS x s) = add (evalS y (evalS x s))

  7. New semantics: evalS :: Expr  Stack  Stack evalS (Val n) s = push n s evalS (Add x y) s = add (evalS y (evalS x s)) Stack operations: push n s = n : s add (n:m:s) = m+n : s

  8. Step 2 – Continuations Make the flow of control explicit by transforming the semantics into continuation-passing style. Definition: A continuation is a function that is applied to the result of another computation.

  9. Aim: define a new semantics evalC :: Expr  Cont  Cont Cont = Stack  Stack such that evalC e c s = c (evalS e s)

  10. New semantics: evalC :: Expr  Cont  Cont evalC (Val n) c s = c (push n s) evalC (Add x y) c s = evalC x (evalC y (c . add)) s Previous semantics: evalS :: Expr  Stack  Stack evalS e = evalC e (λs  s)

  11. Step 3 - Defunctionalise Make the semantics first-order again by applying the technique of defunctionalisation. Basic idea: Represent the continuations that we actually need using a datatype.

  12. New semantics: comp’ :: Expr CodeCode comp’ (Val n) c = PUSH n c comp’ (Add x y) c = comp’ x (comp’ y (ADD c)) comp :: Expr Code comp e = comp’ e HALT A compiler for arithmetic expressions!

  13. New datatype and its interpretation: data Code = PUSH Int Code | ADD Code | HALT exec :: Code  Stack  Stack exec (PUSH n c) s = exec c (n:s) exec (ADD c) (n:m:s) = exec c (m+n : s) exec HALT s = s A virtual machine for arithmetic expressions!

  14. Reflection We now have a three step process for calculating a compiler from a high-level semantics: 1 - Add a stack 2 - Add a continuation 3 - Remove the continuations Can the steps be combined? (see paper)

  15. Summary • Purely calculational approach to developing compilers that are correct by construction; • Only requires simple techniques, and scales to a wide variety of language features; • More sophisticated languages also introduce the idea of using partial specifications.

  16. Further Work • Register-based machines; • Real source/target languages; • Mechanical assistance; • EPSRC application.

More Related