Merge pull request #36 from dvanhorn/next

Next

Author: dvanhorn

www/midterms.scrbl

@@ -11,3 +11,4 @@ date of the midterm.
   @item{Midterm 2: @bold{@m2-date}}
 ]
 
+@include-section["midterms/1.scrbl"]

www/midterms/1.scrbl

@@ -0,0 +1,196 @@
+#lang scribble/manual
+
+@(require (for-label racket))
+
+@title{Midterm 1}
+
+@bold{Due: Tues, Oct 8, 11:59PM}
+
+@(define repo "https://classroom.github.com/a/-N-q7mJ7")
+
+Midterm repository:
+@centered{@link[repo repo]}
+
+The repository contains a single plaintext file @tt{m1.txt}, which you
+can edit to submit your answers to the following questions.  Your
+submision must be pushed by midnight on Tuesday.
+
+During the 48 hours of the exam period, you may only ask private
+questions on Piazza if you need assistance for the course staff.  You
+may not comminicate or collaborate with any one else about the content
+of this exam.
+
+@section{Short answer}
+
+@bold{Question 1}
+
+[10 points]
+
+Briefly describe the difference, if any, between these two Asm instructions:
+
+@verbatim{
+(mov rax rbx)
+}
+
+@verbatim{
+(mov rax (offset rbx 0))
+}
+
+@bold{Question 2}
+
+[10 points]
+
+Briefly describe the difference, if any, between these two Asm instructions:
+
+@verbatim{
+(mov rax (offset rbx 0))
+}
+
+@verbatim{
+(mov (offset rbx 0) rax)
+}
+
+@section{Representation}
+
+@bold{Question 3}
+
+[20 points]
+
+When studying the @secref{Dupe} language, we used the least
+significant bit of a 64-bit integer to indicate whether the value
+being represented was an integer (tagged with @code[#:lang
+"racket"]{#b0}) or a boolean (tagged with @code[#:lang
+"racket"]{#b1}).
+
+Cosider the following alternative design: @racket[#t] is represented
+by the number 0, @racket[#f] is represented by the number 1. All other
+numbers beside 0 and 1 are used to represent integers.
+
+@itemlist[
+
+@item{Describe one way in which this design is worse that the tagging
+approach.}
+
+@item{Describe on way in which this design is better.}
+
+@item{Describe, at a high-level in English, how you could implement
+@racket[add1] using this design.}
+
+]
+
+@section{Interpreting Boolean connectives}
+
+@bold{Question 4}
+
+[25 points]
+
+Consider the following interpreter from @secref{Extort}.
+
+@#reader scribble/comment-reader
+(racketblock 
+;; type Answer = Value | 'err
+ 
+;; Expr -> Answer
+(define (interp e)
+  (match e
+    [(? integer? i) i]
+    [(? boolean? b) b]
+    [`(add1 ,e0)
+     (match (interp e0)
+       [(? integer? i) (add1 i)]
+       [_ 'err])]
+    [`(sub1 ,e0)
+     (match (interp e0)
+       [(? integer? i) (sub1 i)]
+       [_ 'err])]
+    [`(zero? ,e0)
+     (match (interp e0)
+       [(? integer? i) (zero? i)]
+       [_ 'err])]
+    [`(if ,e0 ,e1 ,e2)
+     (match (interp e0)
+       ['err 'err]
+       [v
+        (if v
+            (interp e1)
+            (interp e2))])]))
+
+)
+
+Now extend the interpreter to include @racket[and] and @racket[or]
+connectives similar to those found in Racket.
+
+The @racket[or] form takes any number of subexpressions.  The
+subexpressions are evaluated from left to right until a subexpression
+evaluates to a non-@racket[#f] value, which is produces by the
+@racket[or].  If no such subexpression exists, then @racket[#f] is
+produced.
+
+The @racket[and] form is similar.  It takes any number of
+subexpressions.  The subexpressions are evaluated from left to right
+until a subexpression evaluates to a @racket[#f] value, which is
+produced by @racket[and].  Otherwise, @racket[and] produces the value
+of the last subexpression.  If there are no subexpressions, then
+@racket[#f] is produced.
+
+To make things interesting, you should not use Racket's @racket[and]
+and @racket[or] in @racket[interp].
+
+@section{Compiling a new primitive operation}
+
+@bold{Question 5}
+
+[35 points]
+
+Consider the following excerpt of a compiler that is able to compile
+the @racket[cons] primitive and empty lists @racket['()].  The
+relevant representation information is given as is the function for
+compiling @racket[cons]:
+
+@#reader scribble/comment-reader
+(racketblock
+
+(define result-shift     3)
+(define result-type-mask (sub1 (arithmetic-shift 1 result-shift)))
+(define type-imm         #b000)
+(define type-pair        #b010)
+
+(define imm-shift        (+ 2 result-shift))
+(define imm-type-empty   (arithmetic-shift #b11 result-shift))
+
+;; Expr Expr CEnv -> Asm
+(define (compile-cons e0 e1 c)
+  (let ((c0 (compile-e e0 c))
+        (c1 (compile-e e1 (cons #f c))))
+    `(,@c0
+      (mov (offset rsp ,(- (add1 (length c)))) rax)
+      ,@c1
+      (mov (offset rdi 0) rax)
+      (mov rax (offset rsp ,(- (add1 (length c)))))
+      (mov (offset rdi 1) rax)
+      (mov rax rdi)
+      (or rax ,type-pair)
+      (add rdi 16))))
+)
+
+Now suppose a @racket[map-add1] operation is added to the language
+which takes a single argument, which must be a list of numbers.  The
+operation adds one to each element of the list and produces a list of
+the results.  In other words, @racket[(map-add1 _xs)] should produce
+what @racket[(map add1 _xs)] produces in Racket.
+
+Write a @racket[compile-map-add1] function that compiles an expression
+of the form @racket[(map-add1 _e0)]:
+
+@#reader scribble/comment-reader
+(racketblock
+
+;; Expr CEnv -> Asm
+(define (compile-map-add1 e0 c)
+  ...)
+)
+
+You may use any of the x86 registers as scratch registers, with the
+exception of @racket['rsp] and @racket['rdi] which need to point to
+the stack and heap, respectively.
+

www/notes/iniquity.scrbl

@@ -398,6 +398,9 @@ Using this function, we can touch up our code:
       ret)))
 )
 
+
+@section[#:tag-prefix "iniquity"]{A Compiler for Iniquity}
+
 The last piece of the puzzle is the function for emitting code for a
 complete program:
 

www/notes/iniquity/compile.rkt

@@ -37,13 +37,14 @@
   (match p
     [(list 'begin `(define (,fs . ,xss) ,es) ... e0)
      (let ((ds (compile-defines fs xss es))
-           (c0 (compile-l e0)))
+           (c0 (compile-entry e0)))
        `(,@c0
          ,@ds))]
-    [e (compile-l e)]))
+    [e (compile-entry e)]))
 
 ;; Expr -> Asm
-(define (compile-l e)
+;; Compile e as the entry point
+(define (compile-entry e)
   `(entry
     ,@(compile-e e '())
     ret
@@ -330,5 +331,3 @@
     "_"
     (number->string (eq-hash-code s) 16))))
 
-
-

www/notes/iniquity/interp.rkt

@@ -14,14 +14,15 @@
      (interp-env e '() ds)]
     [e (interp-env e '() '())]))
 
-;; Expr REnv (Listof Defn) -> Integer
+;; Expr REnv (Listof Defn) -> Answer
 (define (interp-env e r ds)
   (match e
     [''() '()]
     [(? value? v) v]
     [(list (? prim? p) es ...)
-     (let ((as (interp-env* es r ds)))
-       (interp-prim p as))]
+     (match (interp-env* es r ds)
+       [(list vs ...) (interp-prim p vs)]
+       [_ 'err])]
     [`(if ,e0 ,e1 ,e2)
      (match (interp-env e0 r ds)
        ['err 'err]
@@ -50,16 +51,17 @@
 
 ;; (Listof Defn) Symbol -> Defn
 (define (defns-lookup ds f)
-  (findf (λ (d) (eq? (first (second d)) f))
+  (findf (match-lambda [`(define (,g . ,_) ,_) (eq? f g)])
          ds))
 
-;; [Listof Expr] REnv -> [Listof Answer]
+;; (Listof Expr) REnv -> (Listof Value) | 'err
 (define (interp-env* es r ds)
   (match es
     ['() '()]
     [(cons e es)
-     (cons (interp-env e r ds)
-           (interp-env* es r ds))]))
+     (match (interp-env e r ds)
+       ['err 'err]
+       [v (cons v (interp-env* es r ds))])]))
 
 ;; Any -> Boolean
 (define (prim? x)
@@ -76,21 +78,22 @@
            (value? (car x))
            (value? (cdr x)))))
 
-;; Prim [Listof Answer] -> Answer
-(define (interp-prim p as)
-  (match (cons p as)
-    [(list p (? value?) ... 'err _ ...) 'err]
-    [(list 'add1 (? integer? i0)) (+ i0 1)]
-    [(list 'sub1 (? integer? i0)) (- i0 1)]
+;; Prim (Listof Value) -> Answer
+(define (interp-prim p vs)
+  (match (cons p vs)
+    [(list 'add1 (? integer? i0))  (add1 i0)]
+    [(list 'sub1 (? integer? i0))  (sub1 i0)]
     [(list 'zero? (? integer? i0)) (zero? i0)]
-    [(list '+ (? integer? i0) (? integer? i1)) (+ i0 i1)]
-    [(list '- (? integer? i0) (? integer? i1)) (- i0 i1)]
-    [(list 'box v0) (box v0)]
-    [(list 'unbox (? box? v0)) (unbox v0)]
-    [(list 'empty? v0) (empty? v0)]
-    [(list 'cons v0 v1) (cons v0 v1)]
-    [(list 'car (cons v0 v1)) v0]
-    [(list 'cdr (cons v0 v1)) v1]
+    [(list 'box v0)                (box v0)]
+    [(list 'unbox (? box? v0))     (unbox v0)]
+    [(list 'empty? v0)             (empty? v0)]
+    [(list 'cons v0 v1)            (cons v0 v1)]
+    [(list 'car (cons v0 v1))      v0]
+    [(list 'cdr (cons v0 v1))      v1]
+    [(list '+ (? integer? i0) (? integer? i1))
+     (+ i0 i1)]
+    [(list '- (? integer? i0) (? integer? i1))
+     (- i0 i1)]
     [_ 'err]))
 
 ;; Env Variable -> Answer