Merge pull request #25 from dvanhorn/next

Next

Author: dvanhorn

www/notes.scrbl

@@ -11,6 +11,7 @@
 @include-section{notes/dupe.scrbl}
 @include-section{notes/extort.scrbl}
 @include-section{notes/fraud.scrbl}
+@include-section{notes/interlude1.scrbl}
 @include-section{notes/grift.scrbl}
 @include-section{notes/hustle.scrbl}
 @;{

www/notes/fraud/asm/interp.rkt

@@ -13,7 +13,7 @@
       #:exists 'truncate
       (λ ()
         (asm-display a)))
-    (system (format "(cd ~a && make -s ~a)" dir t.run))
+    (system (format "(cd ~a && make -s ~a) 2>&1 >/dev/null" dir t.run))
     (delete-file t.s)
     (with-input-from-string
         (with-output-to-string

www/notes/fraud/compile-refactor.rkt

@@ -0,0 +1,105 @@
+#lang racket
+(provide (all-defined-out))
+
+;; type CEnv = [Listof Variable]
+
+;; Expr -> Asm
+(define (compile e)
+  `(entry
+    ,@(compile-e e '())
+    ret
+    err
+    (push rbp)
+    (call error)
+    ret))
+
+;; Expr CEnv -> Asm
+(define (compile-e e c)
+  (match e
+    [(? integer? i)        (compile-integer i)]
+    [(? boolean? b)        (compile-boolean b)]
+    [(? symbol? x)         (compile-variable x c)]    
+    [`(add1 ,e0)           (compile-add1 e0 c)]
+    [`(sub1 ,e0)           (compile-sub1 e0 c)]
+    [`(zero? ,e0)          (compile-zero? e0 c)]
+    [`(if ,e0 ,e1 ,e2)     (compile-if e0 e1 e2 c)]
+    [`(let ((,x ,e0)) ,e1) (compile-let x e0 e1 c)]))
+
+;; Integer -> Asm
+(define (compile-integer i)
+  `((mov rax ,(* i 2))))
+
+;; Boolean -> Asm
+(define (compile-boolean b)
+  `((mov rax ,(if b #b11 #b01))))
+
+;; Expr CEnv -> Asm
+(define (compile-add1 e0 c)
+  (let ((c0 (compile-e e0 c)))
+    `(,@c0
+      ,@assert-integer
+      (add rax 2))))
+
+;; Expr CEnv -> Asm
+(define (compile-sub1 e0 c)
+  (let ((c0 (compile-e e0 c)))
+    `(,@c0
+      ,@assert-integer
+      (sub rax 2))))
+
+;; Expr CEnv -> Asm
+(define (compile-zero? e0 c)
+  (let ((c0 (compile-e e0 c))
+        (l0 (gensym))
+        (l1 (gensym)))
+    `(,@c0
+      ,@assert-integer
+      (cmp rax 0)
+      (mov rax #b01) ; #f
+      (jne ,l0)
+      (mov rax #b11) ; #t
+      ,l0)))
+
+;; Expr Expr Expr CEnv -> Asm
+(define (compile-if e0 e1 e2 c)
+  (let ((c0 (compile-e e0 c))
+        (c1 (compile-e e1 c))
+        (c2 (compile-e e2 c))
+        (l0 (gensym))
+        (l1 (gensym)))
+    `(,@c0
+      (cmp rax #b01) ; compare to #f
+      (je ,l0)       ; jump to c2 if #f
+      ,@c1
+      (jmp ,l1)      ; jump past c2
+      ,l0
+      ,@c2
+      ,l1)))
+
+;; Variable CEnv -> Asm
+(define (compile-variable x c)
+  (let ((i (lookup x c)))
+    `((mov rax (offset rsp ,(- (add1 i)))))))
+
+;; Variable Expr Expr CEnv -> Asm
+(define (compile-let x e0 e1 c)
+  (let ((c0 (compile-e e0 c))
+        (c1 (compile-e e1 (cons x c))))
+    `(,@c0
+      (mov (offset rsp ,(- (add1 (length c)))) rax)
+      ,@c1)))
+
+;; Variable CEnv -> Natural
+(define (lookup x cenv)
+  (match cenv
+    ['() (error "undefined variable:" x)]
+    [(cons y cenv)
+     (match (symbol=? x y)
+       [#t (length cenv)]
+       [#f (lookup x cenv)])]))
+
+(define assert-integer
+  `((mov rbx rax)
+    (and rbx 1)
+    (cmp rbx 0)
+    (jne err)))

www/notes/grift.scrbl

@@ -16,17 +16,135 @@
 
 @title[#:tag "Grift"]{Grift: binary operations}
 
-@codeblock-include["grift/ast.rkt"]
+@emph{If you have to eat two frogs, eat the ugliest one first.}
+
+You may have noticed that up until this point, evaluating compound
+expressions in our language always depend upon the result of a single
+subexpression.  For example, @racket[(add1 _e)] depends upon the
+result of @racket[_e], @racket[(zero? _e)] depends upon @racket[_e],
+and so on.  Even expressions that involve multiple subexpressions such
+as @racket[(if _e0 _e1 _e2)] really only depende on @racket[_e0] to
+determine which of @racket[_e1] or @racket[_e2] to evaluate.
+
+Let's now consider what happens when we have @bold{multiple
+subexpressions} whose results must be combined in order to evaluate an
+expression.  As an example, consider @racket[(+ _e0 _e1)].  We must
+evaluate @emph{both} @racket[_e0] and @racket[_e1] and sum their
+results.
+
+We'll call this language @bold{Grift}.
+
+What's new are the following @emph{binary} operations:
+
+@racketblock[
+(+ _e0 _e1)
+(- _e0 _e1)
+]
+
+This leads to the following grammar for Grift:
 
 @centered[(render-language G)]
 
-@(judgment-form-cases #f)
+We can model it as a datatype as usual:
+
+@codeblock-include["grift/ast.rkt"]
+
+@section{Meaning of Grift programs}
+
+The meaning of Grift programs is pretty straightfoward.  For
+@racket[(+ _e0 _e1)], the meaning is the sum of the meanings of
+@racket[_e0] and @racket[_e1], when they mean integers, otherwise the
+meaning is an error.
+
+
+
+@(define ((rewrite s) lws)
+   (define lhs (list-ref lws 2))
+   (define rhs (list-ref lws 3))
+   (list "" lhs (string-append " " (symbol->string s) " ") rhs ""))
+
+@(require (only-in racket add-between))
+@(define-syntax-rule (show-judgment name cases)
+   (with-unquote-rewriter
+      (lambda (lw)
+        (build-lw (lw-e lw) (lw-line lw) (lw-line-span lw) (lw-column lw) (lw-column-span lw)))
+      (with-compound-rewriters (['+ (rewrite '+)]
+                                ['- (rewrite '–)])
+        (apply centered
+	   (add-between 
+             (map (λ (c) (parameterize ([judgment-form-cases (list c)]
+	                                [judgment-form-show-rule-names #f])
+	                   (render-judgment-form name)))
+	          cases)
+             (hspace 4))))))
+
+The handling of primitives occurs in the following rule:
 
-@centered[(render-judgment-form 𝑮-𝒆𝒏𝒗)]
+@(show-judgment 𝑮-𝒆𝒏𝒗 '("prim"))
 
-@centered[(render-metafunction 𝑮-𝒑𝒓𝒊𝒎 #:contract? #t)]
+It makes use of an auxiliary judgment for interpreting primitives:
 
+@centered[
+   (with-unquote-rewriter
+      (lambda (lw)
+        (build-lw (lw-e lw) (lw-line lw) (lw-line-span lw) (lw-column lw) (lw-column-span lw)))
+      (render-metafunction 𝑮-𝒑𝒓𝒊𝒎 #:contract? #t))]
+
+
+The interpreter is likewise straightforward:
 
 @codeblock-include["grift/interp.rkt"]
 
+We can see that it works as expected:
+
+@ex[
+(interp '(+ 3 4))
+(interp '(+ 3 (+ 2 2)))
+(interp '(+ #f 8))
+]
+
+@section{A Compile for Grift}
+
+Binary expressions are easy to deal with at the level of the semantics
+and interpreter.  However things are more complicated at the level of
+the compiler.
+
+To see the problem consider blindly following the pattern we used:
+
+@#reader scribble/comment-reader
+(racketblock
+;; Expr Expr CEnv -> Asm
+(define (compile-+ e0 e1 c)
+  (let ((c0 (compile-e e0 c))
+        (c1 (compile-e e1 c)))
+    `(,@c0 ; result in rax
+      ,@c1 ; result in rax
+      (add rax _???))))
+)
+
+The problem here is that executing @racket[c0] places its result in
+register @racket['rax], but then executing @racket[c1] places its
+result in @racket['rax], overwriting the value of @racket[e0].
+
+It may be tempting to use another register to stash away the result of
+the first subexpression:
+
+@#reader scribble/comment-reader
+(racketblock
+;; Expr Expr CEnv -> Asm
+(define (compile-+ e0 e1 c)
+  (let ((c0 (compile-e e0 c))
+        (c1 (compile-e e1 c)))
+    `(,@c0 ; result in rax
+      (mov rbx rax)
+      ,@c1 ; result in rax
+      (add rax rbx))))
+)
+
+Can you think of how this could go wrong?
+
+
+
+
+
 @codeblock-include["grift/compile.rkt"]

www/notes/grift/ast.rkt

@@ -3,12 +3,12 @@
 ;; | Integer
 ;; | Boolean
 ;; | Variable
-;; | `(add1 ,Expr)
-;; | `(sub1 ,Expr)
-;; | `(zero? ,Expr)
+;; | (list Prim1 Expr)
+;; | (list Prim2 Expr Expr)
 ;; | `(if ,Expr ,Expr ,Expr)
 ;; | `(let ((,Variable ,Expr)) ,Expr)
-;; | `(+ ,Expr ,Expr)
-;; | `(- ,Expr ,Expr)
 
-;; type Variable = Symbol (except 'add1 'sub1 'if 'let)
+;; type Prim1 = 'add1 | 'sub1 | 'zero?
+;; type Prim2 = '+ | '-
+
+;; type Variable = Symbol (except 'add1 'sub1 'if, etc.)