A Brief Survey of Abstract Machines for Functional Programming Languages
|
|
|
- Neal Walters
- 5 years ago
- Views:
Transcription
1 A Brief Survey of Abstract Machines for Functional Programming Languages Prashant Kumar University of Calgary June 6, 2014 Prashant Kumar (UofC) Abstract Machines June 6, / 24
2 Abstract Machines for Functional Programming languages Some abstract machines for functional languages are as follows:- Modern SECD Krivine Machine Prashant Kumar (UofC) Abstract Machines June 6, / 24
3 Modern SECD Machine 1 An improvement over the SECD machine. 2 Doesn t have a dump. Stack doubles up as a dump. Prashant Kumar (UofC) Abstract Machines June 6, / 24
4 Features of Modern SECD 1 a code pointer c (the instructions yet to be executed) 2 a stack s (holding intermediate result and pending function calls ) 3 an environment e (giving values to the variables ) 4 Modern SECD uses De-Bruijn s Indices to look into the environment. Prashant Kumar (UofC) Abstract Machines June 6, / 24
5 λ-expression to De Bruijn s notation Example Lets consider (λx.xx) (λx.x) and (λx.λy.(xy)) (λx.x) (λy.y) De Bruijn s notation for the above lambda expression are as below (λx.xx) (λx.x) (λ.(#1 #1))(λ. #1) (λx.λy.(xy)) (λx.x) (λy.y) (λ. λ.(#2 #1))(λ.#1)(λ.#1) The De Bruijn Indices have been assumed to start from 1 here. Prashant Kumar (UofC) Abstract Machines June 6, / 24
6 Data structures for Lambda and De Bruijn Lambda expressions Prashant Kumar (UofC) Abstract Machines June 6, / 24
7 Haskell code for converting Lambda expressions to De-Bruijn Lambda expressions Prashant Kumar (UofC) Abstract Machines June 6, / 24
8 Instruction Set in Modern SECD Machine Instruction Set Const - push the constant on the stack Clo(c) - push closure of code c with current environment Ret - terminate current function, jump back to caller App - pop function closure and argument, perform application Add - pop two arguments from the top of the stack and add Access(n) - push n-th field of the environment Prashant Kumar (UofC) Abstract Machines June 6, / 24
9 Compilation Scheme of Modern SECD Machine Compilation Scheme Lambda Terms k λa MN a + b #n Compilation Const (k) Clo( a : Ret) N : M : App b : a : Add Access (n) Prashant Kumar (UofC) Abstract Machines June 6, / 24
10 Example of Compilation Compilation Lets have a look at the compilation of source term: (λ x.x + 1) 2 (λ.#1 + 1) 2 Compiled Code: Const(2) : Clo[Const(1) : Access(1) : Add : Ret] : App Prashant Kumar (UofC) Abstract Machines June 6, / 24
11 Data structures for Code, Environment and Stack in Haskell Prashant Kumar (UofC) Abstract Machines June 6, / 24
12 Haskell Code for Compilation to Modern SECD Commands Prashant Kumar (UofC) Abstract Machines June 6, / 24
13 Machine Transitions in Modern SECD Machine Before After Code Env Stack Code Env Stack Const k : c e s c e k : s Clo(c ) : c e s c e Clos(c, e) : s App : c e Clos(c, e ) : v : s c v : e Clos(c, e) : s Ret : c e v : Clos(c, e ) : s c e v : s Add : c e n : m : s c e (n + m) : s Access(n); c e s c e e(n) : s Clos(c, e) denotes closure of code c with environment e Prashant Kumar (UofC) Abstract Machines June 6, / 24
14 Start and End conditions in Modern SECD Machine Initial State Code = c ; Environment = Nil ; Stack = Nil Final State Code = Nil ; Environment = Nil ; Stack = v Prashant Kumar (UofC) Abstract Machines June 6, / 24
15 Implementation of Transition Function in Haskell Prashant Kumar (UofC) Abstract Machines June 6, / 24
16 Example of evaluation in Modern SECD Machine Lets try evaluating Const(2) : Clo[Const(1) : Access(1) : Add : Ret] : App which is compilation of (λ x. x + 1) 2 Let c = Const(1) : Access(1) : Add : Ret Code Env Stack Const(2) : Clo(c) : App Nil Nil Clo(c) : App Nil Const 2 App Nil Clos(c, Nil) : 2 Const(1) : Access(1) : Add : Ret 2 Clos(Nil, Nil) Access(1) : Add : Ret 2 1 : Clos(Nil, Nil) Add : Ret 2 2 : 1 : Clos(Nil, Nil) Ret 2 3 : Clos(Nil, Nil) Nil Nil 3 Prashant Kumar (UofC) Abstract Machines June 6, / 24
17 Instruction Sets in Krivine Machine 1 Constant 2 Grab 3 Access(n) 4 Push(c) Compilation Scheme Lambda Terms k λa #n MN Compilation Constant k Grab : a Access(n) Push( N ) : M Prashant Kumar (UofC) Abstract Machines June 6, / 24
18 krivine Data Structures in Haskell Prashant Kumar (UofC) Abstract Machines June 6, / 24
19 Haskell Code for Compilation to krivine Commands Prashant Kumar (UofC) Abstract Machines June 6, / 24
20 Example of Compilation in Krivine Machine Lets consider (λx.xx)(λx.x) De Bruijn s notation for the above lambda expression is (λ.(#1#1))(λ.#1) (λ.(#1#1))(λ.#1) Push( λ.#1 ) : λ.(#1#1) Push(Grab, #1 ) : Grab : (#1#1) Push(Grab, Access(1)) : Grab : Push( #1 ) : #1 Push(Grab, Access(1)) : Grab : Push(Access(1)) : Access(1) Prashant Kumar (UofC) Abstract Machines June 6, / 24
21 Machine Transitions in Krivine Machine Before After Code Env Stack Code Env Stack Access(1) : c Clos(c 0, e 0 ) : e s c 0 e 0 s Access(n + 1) : c Clos(c 0, e 0 ) : e s Access(n) e s Push(c ) : c e s c e Clos(c, e) Grab : c e Clos(c, e ) : s c Clos(c, e ) : e s Prashant Kumar (UofC) Abstract Machines June 6, / 24
22 Start and End conditions in Krivine Machine Initial State Code = c; Environment = Nil; Stack = Nil Final State Code = Grab : c; Environment = Nil; Stack = Nil The code is decompiled to get the result. Prashant Kumar (UofC) Abstract Machines June 6, / 24
23 Haskell Code for Implementation of the Transition function of krivine Machine Prashant Kumar (UofC) Abstract Machines June 6, / 24
24 Example of evaluation in Krivine Machine Lets consider the λ-expression (λx.xx)(λx.x). This translates to the following. Push(Grab, Access(1)) : Grab : Push(Access(1)) : Access(1) Let P, G and A stand for Push, Grab and Access respectively. Code Env Stack P(G : A(1)) : G : P(A(1)) : A(1) Nil Nil G : P(A(1)) : A(1) Nil Clos((G : A(1)), Nil) P(A(1)) : A(1) Clos((G : A(1)), Nil) Nil A(1) Clos((G : A(1)), Nil) Clos(A(1), Clos((G : A(1)), Nil) G : A(1) Nil Clos(A(1), Clos((G : A(1)), Nil) A(1) Clos(A(1), Clos((G : A(1)), Nil) Nil A(1) Clos((G : A(1)), Nil) Nil G : A(1) Nil Nil G; A(1) decompiles to λ.1 which is λx.x Prashant Kumar (UofC) Abstract Machines June 6, / 24
Notes on evaluating λ-calculus terms and abstract machines
Notes on evaluating λ-calculus terms and abstract machines J.R.B. Cockett Department of Computer Science, University of Calgary Calgary, T2N 1N4, Alberta, Canada November 17, 2016 1 Introduction In this
Parsing Scheme (+ (* 2 3) 1) * 1
Parsing Scheme + (+ (* 2 3) 1) * 1 2 3 Compiling Scheme frame + frame halt * 1 3 2 3 2 refer 1 apply * refer apply + Compiling Scheme make-return START make-test make-close make-assign make- pair? yes
Implementing functional languages with abstract machines
Implementing functional languages with abstract machines Hayo Thielecke University of Birmingham http://www.cs.bham.ac.uk/~hxt December 9, 2015 Contents Introduction Lambda calculus and programming languages
Compilers: The goal. Safe. e : ASM
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 Compilers: The goal What s our goal
Compiling functional languages
Compiling functional languages Xavier Leroy INRIA Rocquencourt Spring school Semantics of programming languages Agay, 24-29 March 2002 1 Introduction Goal of this lecture: survey implementation techniques
Accurate Step Counting
Accurate Step Counting Catherine Hope and Graham Hutton University of Nottingham Abstract Starting with an evaluator for a language, an abstract machine for the same language can be mechanically derived
The Next 700 Krivine Machines
1 The Next 700 Krivine Machines Rémi Douence * and Pascal Fradet ** douence@emn.fr Pascal.Fradet@inria.fr Abstract: The Krivine machine is a simple and natural implementation of the normal weak-head reduction
Architecture of LISP Machines. Kshitij Sudan March 6, 2008
Architecture of LISP Machines Kshitij Sudan March 6, 2008 A Short History Lesson Alonzo Church and Stephen Kleene (1930) λ Calculus ( to cleanly define "computable functions" ) John McCarthy (late 60 s)
Jatha. Common Lisp in Java. Ola Bini JRuby Core Developer ThoughtWorks Studios.
Jatha Common Lisp in Java Ola Bini JRuby Core Developer ThoughtWorks Studios ola.bini@gmail.com http://olabini.com/blog Common Lisp? Common Lisp? ANSI standard Common Lisp? ANSI standard Powerful Common
CMSC330. Objects, Functional Programming, and lambda calculus
CMSC330 Objects, Functional Programming, and lambda calculus 1 OOP vs. FP Object-oriented programming (OOP) Computation as interactions between objects Objects encapsulate mutable data (state) Accessed
Lambda Calculus. Lecture 4 CS /26/10
Lambda Calculus Lecture 4 CS 565 10/26/10 Pure (Untyped) Lambda Calculus The only value is a function Variables denote functions Functions always take functions as arguments Functions always return functions
State-Transition Machines for Lambda-Calculus Expressions
State-Transition Machines for Lambda-Calculus Expressions David A. Schmidt (schmidt@cis.ksu.edu) Computer Science Department, Aarhus University, Aarhus, Denmark Abstract. The process of compiler generation
Hutton, Graham and Bahr, Patrick (2016) Cutting out continuations. In: WadlerFest, April 2016, Edinburgh, Scotland.
Hutton, Graham and Bahr, Patrick (2016) Cutting out continuations. In: WadlerFest, 11-12 April 2016, Edinburgh, Scotland. Access from the University of Nottingham repository: http://eprints.nottingham.ac.uk/32703/1/cutting.pdf
Introduction to Lambda Calculus. Lecture 7 CS /08/09
Introduction to Lambda Calculus Lecture 7 CS 565 02/08/09 Lambda Calculus So far, we ve explored some simple but non-interesting languages language of arithmetic expressions IMP (arithmetic + while loops)
Scope, Functions, and Storage Management
Scope, Functions, and Storage Management Implementing Functions and Blocks cs3723 1 Simplified Machine Model (Compare To List Abstract Machine) Registers Code Data Program Counter (current instruction)
Verified compilation of a first-order Lisp language
Verified compilation of a first-order Lisp language Lecture 7 MPhil ACS & Part III course, Functional Programming: Implementation, Specification and Verification Magnus Myreen Michaelmas term, 2013 Interpreter
Theory and Implementation of a Functional Programming Language
Rose-Hulman Undergraduate Mathematics Journal Volume 1 Issue 2 Article 3 Theory and Implementation of a Functional Programming Language Ari Lamstein University of Michigan Follow this and additional works
Abstract λ-calculus Machines
Abstract λ-calculus Machines Werner E. Kluge Department of Computer Science University of Kiel D 24105 Kiel, Germany wkinformatik.uni-kiel.de Abstract. This paper is about fully normalizing λ-calculus
A Systematic Study of Functional Language Implementations
1 A Systematic Study of Functional Language Implementations Rémi Douence and Pascal Fradet INRIA / IRISA Campus de Beaulieu, 35042 Rennes Cedex, France douence@irisa.fr fradet@irisa.fr Abstract: We introduce
Functional programming languages
Functional programming languages Part III: program transformations Xavier Leroy INRIA Paris-Rocquencourt MPRI 2-4, 2016 2017 X. Leroy (INRIA) Functional programming languages MPRI 2-4, 2016 2017 1 / 101
Lecture 15 CIS 341: COMPILERS
Lecture 15 CIS 341: COMPILERS Announcements HW4: OAT v. 1.0 Parsing & basic code generation Due: March 28 th No lecture on Thursday, March 22 Dr. Z will be away Zdancewic CIS 341: Compilers 2 Adding Integers
CA Compiler Construction
CA4003 - Compiler Construction David Sinclair When procedure A calls procedure B, we name procedure A the caller and procedure B the callee. A Runtime Environment, also called an Activation Record, is
An introduction to operational semantics and abstract machines
An introduction to operational semantics and abstract machines Hayo Thielecke University of Birmingham, UK http://www.cs.bham.ac.uk/~hxt/ February 29, 2012 Abstract These notes are intended for a third-year
Recursive Definitions, Fixed Points and the Combinator
Recursive Definitions, Fixed Points and the Combinator Dr. Greg Lavender Department of Computer Sciences University of Texas at Austin Recursive Self-Reference Recursive self-reference occurs regularly
Activity. CSCI 334: Principles of Programming Languages. Lecture 4: Fundamentals II. What is computable? What is computable?
Activity CSCI 334: Principles of Programming Languages Lecture 4: Fundamentals II Write a function firsts that, when given a list of cons cells, returns a list of the left element of each cons. ( (a. b)
lambda calculus History 11/28/13 Jianguo Lu A formal system designed to inves:gate func:on defini:on, func:on applica:on, and recursion.
lambda calculus Jianguo Lu 1 History Lambda calculus A formal system designed to inves:gate func:on defini:on, func:on applica:on, and recursion. Introduced by Alonzo Church in 1930s. The calculus can
The Calculator CS571. Abstract syntax of correct button push sequences. The Button Layout. Notes 16 Denotational Semantics of a Simple Calculator
CS571 Notes 16 Denotational Semantics of a Simple Calculator The Calculator Two functions: + and * Unbounded natural numbers (no negatives Conditional: if-then-else Parentheses One memory register 1of
Wednesday, October 15, 14. Functions
Functions Terms void foo() { int a, b;... bar(a, b); void bar(int x, int y) {... foo is the caller bar is the callee a, b are the actual parameters to bar x, y are the formal parameters of bar Shorthand:
CSC 2400: Computer Systems. Using the Stack for Function Calls
CSC 24: Computer Systems Using the Stack for Function Calls Lecture Goals Challenges of supporting functions! Providing information for the called function Function arguments and local variables! Allowing
Introduction to Lambda Calculus. Lecture 5 CS 565 1/24/08
Introduction to Lambda Calculus Lecture 5 CS 565 1/24/08 Lambda Calculus So far, we ve explored some simple but non-interesting languages language of arithmetic expressions IMP (arithmetic + while loops)
Summary: Direct Code Generation
Summary: Direct Code Generation 1 Direct Code Generation Code generation involves the generation of the target representation (object code) from the annotated parse tree (or Abstract Syntactic Tree, AST)
Metaprogramming assignment 3
Metaprogramming assignment 3 Optimising embedded languages Due at noon on Thursday 29th November 2018 This exercise uses the BER MetaOCaml compiler, which you can install via opam. The end of this document
Compiling Code, Procedures and Stacks
Compiling Code, Procedures and Stacks L03-1 RISC-V Recap Computational Instructions executed by ALU Register-Register: op dest, src1, src2 Register-Immediate: op dest, src1, const Control flow instructions
CSC 2400: Computing Systems. X86 Assembly: Function Calls"
CSC 24: Computing Systems X86 Assembly: Function Calls" 1 Lecture Goals! Challenges of supporting functions" Providing information for the called function" Function arguments and local variables" Allowing
The Racket Virtual Machine and Randomized Testing
Noname manuscript No. (will be inserted by the editor) The Racket Virtual Machine and Randomized Testing Casey Klein Matthew Flatt Robert Bruce Findler Received: date / Accepted: date Abstract We present
Concepts Introduced in Chapter 7
Concepts Introduced in Chapter 7 Storage Allocation Strategies Static Stack Heap Activation Records Access to Nonlocal Names Access links followed by Fig. 7.1 EECS 665 Compiler Construction 1 Activation
An Overview to Compiler Design. 2008/2/14 \course\cpeg421-08s\topic-1a.ppt 1
An Overview to Compiler Design 2008/2/14 \course\cpeg421-08s\topic-1a.ppt 1 Outline An Overview of Compiler Structure Front End Middle End Back End 2008/2/14 \course\cpeg421-08s\topic-1a.ppt 2 Reading
Basic Research in Computer Science BRICS RS O. Danvy: A Rational Deconstruction of Landin s SECD Machine
BRICS Basic Research in Computer Science BRICS RS-03-33 O. Danvy: A Rational Deconstruction of Landin s SECD Machine A Rational Deconstruction of Landin s SECD Machine Olivier Danvy BRICS Report Series
CSC 2400: Computer Systems. Using the Stack for Function Calls
CSC 24: Computer Systems Using the Stack for Function Calls Lecture Goals Challenges of supporting functions! Providing information for the called function Function arguments and local variables! Allowing
Today s Menu. >Use the Internal Register(s) >Use the Program Memory Space >Use the Stack >Use global memory
Today s Menu Methods >Use the Internal Register(s) >Use the Program Memory Space >Use the Stack >Use global memory Look into my See examples on web-site: ParamPassing*asm and see Methods in Software and
UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division
UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division Fall, 2001 Prof. R. Fateman SUGGESTED S CS 164 Final Examination: December 18, 2001, 8-11AM
CSC 2400: Computing Systems. X86 Assembly: Function Calls
CSC 24: Computing Systems X86 Assembly: Function Calls 1 Lecture Goals Challenges of supporting functions Providing information for the called function Function arguments and local variables Allowing the
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ August 17, 2007 Lambda Calculus and Type
Stack -- Memory which holds register contents. Will keep the EIP of the next address after the call
Call without Parameter Value Transfer What are involved? ESP Stack Pointer Register Grows by 4 for EIP (return address) storage Stack -- Memory which holds register contents Will keep the EIP of the next
CSC 8400: Computer Systems. Using the Stack for Function Calls
CSC 84: Computer Systems Using the Stack for Function Calls Lecture Goals Challenges of supporting functions! Providing information for the called function Function arguments and local variables! Allowing
Fundamentals and lambda calculus
Fundamentals and lambda calculus Again: JavaScript functions JavaScript functions are first-class Syntax is a bit ugly/terse when you want to use functions as values; recall block scoping: (function ()
Systems I. Machine-Level Programming V: Procedures
Systems I Machine-Level Programming V: Procedures Topics abstraction and implementation IA32 stack discipline Procedural Memory Usage void swap(int *xp, int *yp) int t0 = *xp; int t1 = *yp; *xp = t1; *yp
3.1 λ-calculus: Syntax
3 The Lambda Calculus The Lambda calculus, or λ-calculus, is a model of computation based on the idea that algorithms can be seen as mathematical functions mapping inputs to outputs. It was introduced
Programming Language Concepts: Lecture 19
Programming Language Concepts: Lecture 19 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 19, 01 April 2009 Adding types
Compilation à la Carte
Compilation à la Carte Laurence E. Day Functional Programming Laboratory University of Nottingham led@cs.nott.ac.uk Graham Hutton Functional Programming Laboratory University of Nottingham graham.hutton@nottingham.ac.uk
A formal derivation of an executable Krivine machine
A formal derivation of an executable Krivine machine Wouter Swierstra Universiteit Utrecht IFIP WG 2.1 Meeting 68; Rome, Italy 1 β reduction (λx. t0) t1 t0 {t1/x} 2 Motivation Implementing β-reduction
CS 320: Concepts of Programming Languages
CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 24: Compilation: Implementing Function Calls o Function Definitions in Mini-C o The Run-Time
Procedures and Stacks
Procedures and Stacks Daniel Sanchez Computer Science & Artificial Intelligence Lab M.I.T. March 15, 2018 L10-1 Announcements Schedule has shifted due to snow day Quiz 2 is now on Thu 4/12 (one week later)
CS 4110 Programming Languages & Logics
CS 4110 Programming Languages & Logics Lecture 38 Typed Assembly Language 30 November 2012 Schedule 2 Monday Typed Assembly Language Wednesday Polymorphism Stack Types Today Compilation Course Review Certi
Pure (Untyped) λ-calculus. Andrey Kruglyak, 2010
Pure (Untyped) λ-calculus Andrey Kruglyak, 2010 1 Pure (untyped) λ-calculus An example of a simple formal language Invented by Alonzo Church (1936) Used as a core language (a calculus capturing the essential
Lecture XXIV: Review Xuan Guo CSC 3210 Computer Organization and Programming Georgia State University April 23, 2015 Xuan Guo Lecture XXIV: Review
CSC 3210 Computer Organization and Programming Georgia State University April 23, 2015 This lecture Review: set instruction register saving subroutine linkage arguments passing printf function instruction
Com S 541. Programming Languages I
Programming Languages I Lecturer: TA: Markus Lumpe Department of Computer Science 113 Atanasoff Hall http://www.cs.iastate.edu/~lumpe/coms541.html TR 12:40-2, W 5 Pramod Bhanu Rama Rao Office hours: TR
A Parallel Complexity Model for Functional Languages
A Parallel Complexity Model for Functional Languages Guy Blelloch October 20, 1994 CMU-CS-94-196 John Greiner School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213 This research was
Address Modes effective address
Address Modes The MARIE supports only three addressing modes: immediate, direct, and indirect. We are now going to discuss addressing modes in general. Most computers support quite a few of these modes.
Functional programming languages
Functional programming languages Part I: interpreters and operational semantics Xavier Leroy INRIA Paris-Rocquencourt MPRI 2-4, 2016 2017 X. Leroy (INRIA) Functional programming languages MPRI 2-4, 2016
Lecture 4 CIS 341: COMPILERS
Lecture 4 CIS 341: COMPILERS CIS 341 Announcements HW2: X86lite Available on the course web pages. Due: Weds. Feb. 7 th at midnight Pair-programming project Zdancewic CIS 341: Compilers 2 X86 Schematic
CS 314 Principles of Programming Languages. Lecture 13
CS 314 Principles of Programming Languages Lecture 13 Zheng Zhang Department of Computer Science Rutgers University Wednesday 19 th October, 2016 Zheng Zhang 1 CS@Rutgers University Class Information Reminder:
Push/enter vs eval/apply. Simon Marlow Simon Peyton Jones
Push/enter vs eval/apply Simon Marlow Simon Peyton Jones The question Consider the call (f x y). We can either Evaluate f, and then apply it to its arguments, or Push x and y, and enter f Both admit fully-general
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
Accurate Step Counting
Accurate Step Counting Catherine Hope and Graham Hutton School of Computer Science and IT University of Nottingham, UK {cvh,gmh}@cs.nott.ac.uk Abstract Starting with an evaluator for a language, an abstract
Lambda Calculus and Extensions as Foundation of Functional Programming
Lambda Calculus and Extensions as Foundation of Functional Programming David Sabel and Manfred Schmidt-Schauß 29. September 2015 Lehrerbildungsforum Informatik Last update: 30. September 2015 Overview
Dr. D.M. Akbar Hussain
1 2 Compiler Construction F6S 1 3 4 Compiler Construction F6S 2 5 6 Compiler Construction F6S 3 7 8 Compiler Construction F6S 4 a=b*- c + b*- c 9 a=b*- c + b*- c 10 Compiler Construction F6S 5 a=b*- c
The Art of Recursion: Problem Set 10
The Art of Recursion: Problem Set Due Tuesday, November Tail recursion A recursive function is tail recursive if every recursive call is in tail position that is, the result of the recursive call is immediately
Deriving Compilers and Virtual Machines for a Multi-Level Language
Deriving Compilers and Virtual Machines for a Multi-Level Language Atsushi Igarashi 1 and Masashi Iwaki 2 1 Kyoto University, Japan, igarashi@kuis.kyoto-u.ac.jp 2 Hitachi, Ltd., Japan, masashi.iwaki.ew@hitachi.com
Typed Lambda Calculus and Exception Handling
Typed Lambda Calculus and Exception Handling Dan Zingaro zingard@mcmaster.ca McMaster University Typed Lambda Calculus and Exception Handling p. 1/2 Untyped Lambda Calculus Goal is to introduce typing
Subroutines. int main() { int i, j; i = 5; j = celtokel(i); i = j; return 0;}
Subroutines Also called procedures or functions Example C code: int main() { int i, j; i = 5; j = celtokel(i); i = j; return 0;} // subroutine converts Celsius to kelvin int celtokel(int i) { return (i
The Racket virtual machine and randomized testing
DOI 10.1007/s10990-013-9091-1 The Racket virtual machine and randomized testing Casey Klein Matthew Flatt Robert Bruce Findler Springer Science+Business Media New York 2013 Abstract We present a PLT Redex
CMSC 336: Type Systems for Programming Languages Lecture 5: Simply Typed Lambda Calculus Acar & Ahmed January 24, 2008
CMSC 336: Type Systems for Programming Languages Lecture 5: Simply Typed Lambda Calculus Acar & Ahmed January 24, 2008 Contents 1 Solution to the Exercise 1 1.1 Semantics for lambda calculus.......................
Lecture 4: Instruction Set Design/Pipelining
Lecture 4: Instruction Set Design/Pipelining Instruction set design (Sections 2.9-2.12) control instructions instruction encoding Basic pipelining implementation (Section A.1) 1 Control Transfer Instructions
Memory Usage 0x7fffffff. stack. dynamic data. static data 0x Code Reserved 0x x A software convention
Subroutines Why we use subroutines more modular program (small routines, outside data passed in) more readable, easier to debug code reuse i.e. smaller code space Memory Usage A software convention stack
From Math to Machine A formal derivation of an executable Krivine Machine Wouter Swierstra Brouwer Seminar
From Math to Machine A formal derivation of an executable Krivine Machine Wouter Swierstra Brouwer Seminar β reduction (λx. t0) t1 t0 {t1/x} Substitution Realizing β-reduction through substitution is a
Last class. CS Principles of Programming Languages. Introduction. Outline
Last class CS6848 - Principles of Programming Languages Principles of Programming Languages V. Krishna Nandivada IIT Madras Interpreters A Environment B Cells C Closures D Recursive environments E Interpreting
Lambda Calculus: Implementation Techniques and a Proof. COS 441 Slides 15
Lambda Calculus: Implementation Techniques and a Proof COS 441 Slides 15 Last Time: The Lambda Calculus A language of pure functions: values e ::= x \x.e e e v ::= \x.e With a call-by-value operational
Introduction to the λ-calculus
Announcements Prelim #2 issues: o Problem 5 grading guide out shortly o Problem 3 (hashing) issues Will be on final! Friday RDZ office hours are 11-12 not 1:30-2:30 1 Introduction to the λ-calculus Today
INF 212 ANALYSIS OF PROG. LANGS PROCEDURES & FUNCTIONS. Instructors: Kaj Dreef Copyright Instructors.
INF 212 ANALYSIS OF PROG. LANGS PROCEDURES & FUNCTIONS Instructors: Kaj Dreef Copyright Instructors. Subroutines aka Procedures Historically: blocks of instructions executed several times during program
Program Exploitation Intro
Program Exploitation Intro x86 Assembly 04//2018 Security 1 Univeristà Ca Foscari, Venezia What is Program Exploitation "Making a program do something unexpected and not planned" The right bugs can be
Point-Free Templates
Point-Free Templates European LLVM Developers Meeting 2018 Andrew Gozillon, Dr. Paul Keir School of Engineering and Computing University of the West of Scotland, Paisley Campus April 17th, 2018 Introduction
Fundamentals and lambda calculus. Deian Stefan (adopted from my & Edward Yang s CSE242 slides)
Fundamentals and lambda calculus Deian Stefan (adopted from my & Edward Yang s CSE242 slides) Logistics Assignments: Programming assignment 1 is out Homework 1 will be released tomorrow night Podcasting:
CS 4110 Programming Languages & Logics. Lecture 35 Typed Assembly Language
CS 4110 Programming Languages & Logics Lecture 35 Typed Assembly Language 1 December 2014 Announcements 2 Foster Office Hours today 4-5pm Optional Homework 10 out Final practice problems out this week
Part 7. Stacks. Stack. Stack. Examples of Stacks. Stack Operation: Push. Piles of Data. The Stack
Part 7 Stacks The Stack Piles of Data Stack Stack A stack is an abstract data structure that stores objects Based on the concept of a stack of items like a stack of dishes Data can only be added to or
Talen en Compilers. Johan Jeuring , period 2. December 15, Department of Information and Computing Sciences Utrecht University
Talen en Compilers 2016-2017, period 2 Johan Jeuring Department of Information and Computing Sciences Utrecht University December 15, 2016 9 Simple stack machine 9-1 Recap: Semantic functions In the previous
Part I. Historical Origins
Introduction to the λ-calculus Part I CS 209 - Functional Programming Dr. Greg Lavender Department of Computer Science Stanford University Historical Origins Foundations of Mathematics (1879-1936) Paradoxes
G Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter
Towards native higher-order remote procedure calls
Towards native higher-order remote procedure calls Olle Fredriksson Dan R. Ghica Bertram Wheen University of Birmingham, UK Abstract We present a new abstract machine, called DH, which models the execution
Improving the Lazy Krivine Machine
Improving the Lazy Krivine Machine Daniel P. Friedman, Abdulaziz Ghuloum, Jeremy G. Siek, and Lynn Winebarger Indiana University Abstract. Krivine presents the K machine, which produces weak head normal
Linked Lists, Stacks, and Queues
Department of Computer Science and Engineering Chinese University of Hong Kong In a nutshell, a data structure describes how data are stored in memory, in order to facilitate certain operations. In all
Turtles All The Way Down
Turtles All The Way Down Bertrand Russell had just finished giving a public lecture on the nature of the universe. An old woman said Prof. Russell, it is well known that the earth rests on the back of
CS558 Programming Languages Winter 2018 Lecture 4a. Andrew Tolmach Portland State University
CS558 Programming Languages Winter 2018 Lecture 4a Andrew Tolmach Portland State University 1994-2018 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.
Machine code. Nils Jansen December 12, 2017
Machine code Nils Jansen December 12, 2017 Overview So far Circuits Memory ALU Data Path Fetch-Decode-Execute Cycle Fetch-decode-execute cycle Today Machine code Stack 2 Recap: Execute-phase: Computation
Closures & Environments. CS4410: Spring 2013
Closures & Environments CS4410: Spring 2013 "Functional" Languages: Lisp, Scheme, Miranda, Hope, ML, OCaml, Haskell, Functions are first-class not just for calling can pass to other functions (map), return
Homework 5. Notes. Turn-In Instructions. Reading. Problems. Handout 19 CSCI 334: Spring (Required) Read Mitchell, Chapters 6 and 7.
Homework 5 Due Wednesday, 14 March Handout 19 CSCI 334: Spring 2018 Notes This homework has two types of problems: Problems: You will turn in answers to these questions. Pair Programming: This part involves
CSE 341: Programming Languages
CSE 341: Programming Languages Winter 2005 Lecture 17 varargs and apply, implementing higher-order functions CSE341 Winter 2005, Lecture 17 1 Today: Some easy Scheme odds and ends Implementing higher-order
Compilers and Code Optimization EDOARDO FUSELLA
Compilers and Code Optimization EDOARDO FUSELLA Contents Data memory layout Instruction selection Register allocation Data memory layout Memory Hierarchy Capacity vs access speed Main memory Classes of
CS 31: Intro to Systems Functions and the Stack. Martin Gagne Swarthmore College February 23, 2016
CS 31: Intro to Systems Functions and the Stack Martin Gagne Swarthmore College February 23, 2016 Reminders Late policy: you do not have to send me an email to inform me of a late submission before the
BRICS. A Concrete Framework for Environment Machines. BRICS RS-06-3 Biernacka & Danvy: A Concrete Framework for Environment Machines
BRICS RS-06-3 Biernacka & Danvy: A Concrete Framework for Environment Machines BRICS Basic Research in Computer Science A Concrete Framework for Environment Machines Małgorzata Biernacka Olivier Danvy