Compiler Construction | Lecture 14 | Interpreters

Eelco Visser
CS4200 Compiler Construction
TU Delft
December 2018
Lecture 14: Interpreters

!3
Design and implementation of DynSem, a
domain-specific language for the definition
of the dynamic semantics of programming
languages.
DynSem provides facilities for implicitly
passing memory (environment, store).
DynSem specifications can be compiled to or
interpreted as interpreters for the languages
they define.
http://dx.doi.org/10.4230/LIPIcs.RTA.2015.365
RTA 2015

!4
This paper describes the partial evaluation
of the DynSem meta-interpreter with an object
program.
The implementation makes use of Truffle a
framework for run-time (online) partial
evaluation.
Truffle gets most of it benefit from Graal,
an implementation of the JVM with special
support for partial evaluation.
https://doi.org/10.1145/3237009.3237018
ManLang 2018

What is the meaning of a program?
6
meaning(p) = what happens when executing the
generated (byte) code to which p is compiled
source
code
parse generate
machine
code
check
meaning(p) = behavior(p)

What is the meaning of a program?
7
Mapping input to output
What is behavior?
Changes to state of the system
How can we observe behavior?
meaning(p) = behavior(p)
Which behavior is essential, which accidental?

How can we deﬁne the semantics of a program?
8
Is there a more direct description of semanticsL1?
Compiler deﬁnes translational semantics
semanticsL1(p) = semanticsL2(translate(p))
Requires understanding translate and semanticsL2
How do we know that translate is correct?

source
code
machine
code
translate
value
value
equal
run
semanticsL1
run
semanticsL2

Verifying Compiler Correctness
10
Direct semantics of source language provides a speciﬁcation
How to check correctness?
Testing: for many programs p (and inputs i) test that
run(p)(i) == run(translate(p))(i)
Veriﬁcation: for all programs p (and inputs i) prove that
run(p)(i) == run(translate(p))(i)

Validating Semantics
11
Is this the right semantics?
Testing: for many programs p (and inputs i) test that
run(p)(i) == v
Requires specifying desired <p, i, v> combinations 
(aka unit testing)

The CompCert C Compiler
12
http://compcert.inria.fr/compcert-C.html

Compiler Construction Courses of the Future
13
Language Specification
syntax definition
name binding
type system
dynamic semantics
translation
transformation
safety properties
Language Testing
test generation
Language Implementation
generating implementations
from specifications
parser generation
constraint resolution
partial evaluation
…
Language Verification
proving correctness

What is the result of execution of a program?
- How is that result achieved?

Natural Semantics
- How is overall result of execution obtained?

Structural Operational Semantics
- What are the individual steps of an execution?

Deﬁned using a transition system
!15
Operational Semantics

!17
Design and implementation of DynSem, a
domain-specific language for the definition
of the dynamic semantics of programming
languages.
DynSem provides facilities for implicitly
passing memory (environment, store).
DynSem specifications can be compiled to or
interpreted as interpreters for the languages
they define.
http://dx.doi.org/10.4230/LIPIcs.RTA.2015.365
RTA 2015

Interpreters for Spoofax Languages
18

Example: DynSem Semantics of PAPL-Box
19
let
fac = box(0)
in
let f = fun (n) {
if (n == 0)
1
else
n * (unbox(fac) (n - 1))
end
}
in
setbox(fac, f);
unbox(fac)(10)
end
end
Features
- Arithmetic
- Booleans
- Comparisons
- Mutable variables
- Functions
- Boxes
Components
- Syntax in SDF3
- Dynamic Semantics in DynSem

Abstract Syntax from Concrete Syntax
20
module Arithmetic
imports Expressions
imports Common
context-free syntax
Expr.Num = INT
Expr.Plus = [[Expr] + [Expr]] {left}
Expr.Minus = [[Expr] - [Expr]] {left}
Expr.Times = [[Expr] * [Expr]] {left}
Expr.Mod = [[Expr] % [Expr]] {left}
context-free priorities
{left: Expr.Times Expr.Mod }
> {left: Expr.Minus Expr.Plus }
module Arithmetic-sig
imports Expressions-sig
imports Common-sig
signature
sorts Expr
constructors
Num : INT -> Expr
Plus : Expr * Expr -> Expr
Minus : Expr * Expr -> Expr
Times : Expr * Expr -> Expr
Mod : Expr * Expr -> Expr
src-gen/ds-signatures/Arithmetic-sig

Values, Meta-Variables, and Arrows
21
module values
signature
sorts V Unit
constructors
U : Unit
variables
v: V
module expressions
imports values
signature
arrows
Expr --> V
variables
e : Expr
x : String

Term Reduction Rules
22
module arithmetic-explicit
imports expressions primitives Arithmetic-sig
signature
constructors
NumV: Int -> V
rules
Num(__String2INT__(n)) --> NumV(str2int(n)).
Plus(e1, e2) --> NumV(plusI(i1, i2))
where
e1 --> NumV(i1); e2 --> NumV(i2).
Minus(e1, e2) --> NumV(minusI(i1, i2))
where
e1 --> NumV(i1); e2 --> NumV(i2).
module expressions
imports values
signature
arrows
Expr --> V
variables
e : Expr
x : String

Native Operations
23
module arithmetic-explicit
imports expressions primitives Arithmetic-sig
signature
constructors
NumV: Int -> V
rules
Num(__String2INT__(n)) --> NumV(str2int(n)).
where
e1 --> NumV(i1); e2 --> NumV(i2).
Minus(e1, e2) --> NumV(minusI(i1, i2))
where
e1 --> NumV(i1); e2 --> NumV(i2).
module primitives
signature
native operators
str2int : String -> Int
plusI : Int * Int -> Int
minusI : Int * Int -> Int
public class Natives {
public static int plusI_2(int i1, int i2) {
return i1 + i2;
}
public static int str2int_1(String s) {
return Integer.parseInt(s);
}
}

Arrows as Coercions
24
rules
where
e1 --> NumV(i1);
e2 --> NumV(i2).
rules
Plus(NumV(i1), NumV(i2)) --> NumV(plusI(i1, i2)).
signature
constructors
Plus : Expr * Expr -> Expr
NumV : Int -> V
arrows
Expr --> V

Modular
25
module boolean
imports Booleans-sig expressions
signature
constructors
BoolV : Bool -> V
rules
True() --> BoolV(true).
False() --> BoolV(false).
Not(BoolV(false)) --> BoolV(true).
Not(BoolV(true)) --> BoolV(false).
Or(BoolV(true), _) --> BoolV(true).
Or(BoolV(false), e) --> e.
And(BoolV(false), _) --> BoolV(false).
And(BoolV(true), e) --> e.
module arithmetic
imports Arithmetic-sig
imports expressions
imports primitives
signature
constructors
NumV: Int -> V
rules
Num(str) --> NumV(str2int(str)).
Minus(NumV(i1), NumV(i2)) --> NumV(minusI(i1, i2)).
Times(NumV(i1), NumV(i2)) --> NumV(timesI(i1, i2)).
Mod(NumV(i1), NumV(i2)) --> NumV(modI(i1, i2)).
module comparison
imports Comparisons-sig arithmetic boolean
rules
Gt(NumV(i1), NumV(i2)) --> BoolV(gtI(i1, i2)).
Eq(NumV(i1), NumV(i2)) --> BoolV(eqI(i1, i2)).
Eq(BoolV(b1), BoolV(b2)) --> BoolV(eqB(b1, b2)).
Interpreter is not deﬁned as a single match over sort

Control-Flow
26
module controlflow
imports ControlFlow-sig
imports expressions
imports boolean
rules
Seq(v, e2) --> e2.
If(BoolV(true), e1, _) --> e1.
If(BoolV(false), _, e2) --> e2.
module controlflow
imports ControlFlow-sig
imports expressions
imports boolean
rules
Seq(e1, e2) --> v2
where
e1 --> v1;
e2 --> v2.
If(e1, e2, e3) --> v
where
e1 --> BoolV(true);
e2 --> v.
If(e1, e2, e3) --> v
where
e1 --> BoolV(false);
e3 --> v.

Immutable Variables: Environment Passing
27
constructors
Let : ID * Expr * Expr -> Expr
Var : ID -> Expr
module variables
imports Variables-sig environment
rules
E |- Let(x, v: V, e2) --> v2
where
Env {x |--> v, E} |- e2 --> v2.
E |- Var(x) --> E[x].
module environment
imports values
signature
sort aliases
Env = Map<String, V>
variables
E : Env

First-Class Functions: Environment in Closure
28
module unary-functions
imports expressions environment
signature
constructors
ClosV : String * Expr * Env -> V
rules
E |- Fun(x, e) --> ClosV(x, e, E).
E |- App(e1, e2) --> v
where
E |- e1 --> ClosV(x, e, E');
E |- e2 --> v2;
Env {x |--> v2, E'} |- e --> v.
constructors
Fun : ID * Expr -> Expr
App : Expr * Expr -> Expr
module environment
imports values
signature
sort aliases
Env = Map<String, V>
variables
E : Env

Implicit Propagation
29
rules
E |- Plus(e1, e2) --> NumV(plusI(i1, i2))
where
E |- e1 --> NumV(i1);
E |- e2 --> NumV(i2).
rules
where
e1 --> NumV(i1);
e2 --> NumV(i2).
rules

Mutable Boxes: Store
30
module box
imports store arithmetic
signature
constructors
Box : Expr -> Expr
Unbox : Expr -> Expr
SetBox : Expr * Expr -> Expr
constructors
BoxV: Int -> V
rules
Box(e) :: S --> BoxV(loc) :: Store {loc |--> v, S'}
where e :: S --> v :: S';
fresh => loc.
Unbox(BoxV(loc)) :: S --> S[loc].
SetBox(BoxV(loc), v) :: S --> v :: Store {loc |--> v, S}.
module store
imports values
signature
sort aliases
Store = Map<Int, V>
variables
S : Store

Mutable Variables: Environment + Store
31
constructors
Let : ID * Expr * Expr -> Expr
Var : ID -> Expr
Set : String * Expr -> Expr
module variables-mutable
imports Variables-sig store
rules
E |- Var(x) :: S --> v :: S
where E[x] => loc; S[loc] => v.
E |- Let(x, v, e2) :: S1 --> v2 :: S3
where
fresh => loc;
{loc |--> v, S1} => S2;
Env {x |--> loc, E} |- e2 :: S2 --> v2 :: S3.
E |- Set(x, v) :: S --> v :: Store {loc |--> v, S}
where E[x] => loc.
module store
imports values
signature
sort aliases
Env = Map<ID, Int>
Store = Map<Int, V>
variables
E : Env
S : Store

Implicit Store Threading
32
rules
E |- Plus(e1, e2) :: S1 --> NumV(plusI(i1, i2)) :: S3
where
E |- e1 :: S1 --> NumV(i1) :: S2;
E |- e2 :: S2 --> NumV(i2) :: S3.
rules
where
e1 --> NumV(i1);
e2 --> NumV(i2).
rules

Abstraction: Env/Store Meta Functions
33
module store
imports values
signature
sort aliases
Env = Map<String, Int>
Store = Map<Int, V>
variables
E : Env
S : Store
arrows
readVar : String --> V
bindVar : String * V --> Env
writeVar : String * V --> V
allocate : V --> Int
write : Int * V --> V
read : Int --> V
rules
allocate(v) --> loc
where
fresh => loc;
write(loc, v) --> _.
write(loc, v) :: S -->
v :: Store {loc |--> v, S}.
read(loc) :: S --> S[loc] :: S.
rules
bindVar(x, v) --> {x |--> loc}
where allocate(v) --> loc.
E |- readVar(x) --> read(E[x]).
E |- writeVar(x, v) --> write(E[x], v).

Boxes with Env/Store Meta Functions
34
module boxes
signature
constructors
Box : Expr -> Expr
Unbox : Expr -> Expr
SetBox : Expr * Expr -> Expr
constructors
BoxV: V -> V
rules
Box(v) --> BoxV(NumV(allocate(v))).
Unbox(BoxV(NumV(loc))) --> read(loc).
SetBox(BoxV(NumV(loc)), v) --> write(loc, v).

Mutable Variables with Env/Store Meta Functions
35
module variables
imports expressions store
rules
Var(x) --> readVar(x).
E |- Let(x, v1, e) --> v2
where
bindVar(x, v1) --> E';
Env {E', E} |- e --> v2.
Set(x, v) --> v
where
writeVar(x, v) --> _.
constructors
Let : String * Expr * Expr -> Expr
Var : String -> Expr
Set : String * Expr -> Expr

Functions with Multiple Arguments
36
module functions
imports Functions-sig
imports variables
signature
constructors
ClosV : List(ID) * Expr * Env -> V
bindArgs : List(ID) * List(Expr) --> Env
rules
E |- Fun(xs, e) --> ClosV(xs, e, E).
App(ClosV(xs, e_body, E_clos), es) --> v'
where
bindArgs(xs, es) --> E_params;
Env {E_params, E_clos} |- e_body --> v'.
bindArgs([], []) --> {}.
bindArgs([x | xs], [e | es]) --> {E, E'}
where
bindVar(x, e) --> E;
bindArgs(xs, es) --> E'.

Tiger in DynSem
37https://github.com/MetaBorgCube/metaborg-tiger

Generating AST Interpreter from Dynamic Semantics
39
DynSem
Speciﬁcation
AST Value
Interpreter
in Java

DynSem Meta-Interpreter
40
DynSem
Speciﬁcation
AST
AST Rep. of
DynSem Rules
Value
Term Rep.
in Java
DynSem
Interpreter

Trufﬂe: Partial Evaluation of AST Interpreters
41
Würthinger et al. One VM to rule them all. Onward! 2013

!42
This paper describes the partial evaluation
of the DynSem meta-interpreter with an object
program.
The implementation makes use of Truffle a
framework for run-time (online) partial
evaluation.
Truffle gets most of it benefit from Graal,
an implementation of the JVM with special
support for partial evaluation.
https://doi.org/10.1145/3237009.3237018
ManLang 2018

!54
How is this relevant for compilers and interpreters?

Instance-specific program
- Can make very efficient

- Hard to maintain (performance interventions tangled with implementation)

- Hard to reuse for variants

Generic program
- Parametric in instances

- Easy to maintain

- Easy to reuse for variants

- Not efficient: overhead of parametricity

Partial evaluation
- Specialize generic program to specific instances
!63
Partial Evaluation: Summary

Specializing a meta-interpreter
- Meta-interpreter: DynSem specifications executed using interpreter

- Partial evaluation: remove two stages of interpretation

- Encouraging results using Truffle/Graal

- How close to native speed can we get?

Generate byte code compiler
- Input: DynSem specification

- Output: compiler from source to (custom) byte code

- Output: byte code interpreter
!64
Some Research Projects

Partial evaluation
- Oﬄine vs online partial evaluation

- Binding-time analysis

Multi-stage programming
- Explicit binding time annotations

Just-in-time (JIT) compilation
- Interpreter selectively compiles code (fragments) to machine code

Techniques for partial evaluation
- Meta-tracing

- Run-time specialisation (Truﬄe/Graal)
!65
Further Study

!66
Except where otherwise noted, this work is licensed under

Compiler Construction | Lecture 14 | Interpreters

More Related Content

What's hot (20)

Similar to Compiler Construction | Lecture 14 | Interpreters (20)

More from Eelco Visser (15)

Recently uploaded (20)

Compiler Construction | Lecture 14 | Interpreters