Rework Extort notes.

Author: dvanhorn

www/notes/dupe.scrbl

@@ -21,6 +21,11 @@
 
 @title[#:tag "Dupe"]{Dupe: a duplicity of types}
 
+@emph{There are 10 types of values...}
+
+@table-of-contents[]
+
+@section{Integers and Booleans}
 
 Up until now we have worked to maintain a single type of values:
 integers.  This led to some awkwardness in the design of conditionals.

www/notes/extort.scrbl

@@ -37,22 +37,6 @@ programs: values and errors.  We will say that evaluation produces an
 
 @section{Meaning of Extort programs}
 
-The meaning of Extort programs...
-
-@itemlist[
-
-@item{...}
-
-]
-
-Let's consider some examples:
-
-@itemlist[
-
-@item{...}
-
-]
-
 Languages adopt several approaches to type mismatches:
 
 @itemlist[
@@ -68,7 +52,18 @@ We've previously seen the last approach.  Now let's do what Racket
 does and signal an error.
 
 
+The meaning of Extort programs that have type errors will now be
+defined as @racket['err]:
+
+@itemlist[
+
+@item{@racket[(add1 #f)]: means @racket['err].}
+
+@item{@racket[(zero? #t)]: means @racket['err].}
 
+@item{@racket[(if (zero? #f) 1 2)]: means @racket['err].}
+
+]
 
 @(define ((rewrite s) lws)
    (define lhs (list-ref lws 2))
@@ -99,40 +94,42 @@ And there are four rules for propagating errors from subexpressions:
 
 
 
-Now what does the semantics say about @racket['(add1 #f)]?  What about
-@racket['(if 7 #t -2)]?
+Now what does the semantics say about @racket[(add1 #f)]?  What about
+@racket[(if 7 #t -2)]?
 
 
-The interpreter ...
+The signature of the interpreter is extended to produce answers.  Each
+use of a Racket primitive is guarded by checking the type of the
+arguments and an error is produced if the check fails.  Errors are
+also propagated when a subexpression produces an error:
 
 @codeblock-include["extort/interp.rkt"]
 
 We can confirm the interpreter computes the right result for the
 examples given earlier:
 
 @ex[
-'...
+(interp '(add1 #f))
+(interp '(zero? #t))
+(interp '(if (zero? #f) 1 2))
 ]
 
-Correctness...
-
-@section{An Example of Extort compilation}
-
-Suppose we want to compile ...
+The statement of correctness stays the same, but now observe that
+there is no way to crash the interpreter with any @tt{Expr} value.
 
-What needs to happen? ...
 
-@;codeblock-include["extort/asm/ast.rkt"]
+@section{An Example of Extort compilation}
 
-We omit the printer code, which is mundane.  See
-@link["extort/asm/printer.rkt"]{@tt{asm/printer.rkt}} for details.
+Suppose we want to compile @racket[(add1 #f)], what needs to happen?
+Just as in the interpreter, we need to check the integerness of the
+argument's value before doing the addition operation.
 
-We must extend the run-time system with a C function called @tt{error}
+We extend the run-time system with a C function called @tt{error}
 that prints "err" and exits:
 
 @filebox-include[fancy-c "extort/main.c"]
 
-Compiler...
+The compiler now emits code to check the type of arguments:
 
 @codeblock-include["extort/compile.rkt"]
 
@@ -156,4 +153,19 @@ Here are some examples running the compiler:
 (asm-interp (compile '(if (zero? #t) 1 2)))
 ]
 
+Since the interpreter and compiler have well defined specifications
+for what should happen when type errors occur, we can test in the
+usual way again:
+
+@ex[
+(define (check-correctness e)
+  (check-equal? (asm-interp (compile e))
+                (interp e)
+                e))
+
+(check-correctness '(add1 7))
+(check-correctness '(add1 #f))
+]
+
+
 

www/notes/extort/compile.rkt

@@ -1,65 +1,60 @@
 #lang racket
 (provide (all-defined-out))
-(require "compile/help.rkt")
 
 ;; Expr -> Asm
 (define (compile e)
   `(entry
     ,@(compile-e e)
     ret
     err
-    (push rbp) ; doesn't seem to matter what we push
+    (push rbp) ; push before calling
     (call error)))
 
 ;; Expr -> Asm
 (define (compile-e e)
   (match e
     [(? integer? i)
-     `((mov rax ,(arithmetic-shift i fixnum-shift)))]
+     `((mov rax ,(* i 2)))]
     [(? boolean? b)
-     `((mov rax ,(if b true-rep false-rep)))]
+     `((mov rax ,(if b #b11 #b01)))]
     [`(add1 ,e0)
      (let ((c0 (compile-e e0)))
        `(,@c0
          ,@assert-integer
-         (add rax ,(arithmetic-shift 1 fixnum-shift))))]
+         (add rax 2)))]
     [`(sub1 ,e0)
      (let ((c0 (compile-e e0)))
        `(,@c0
          ,@assert-integer
-         (sub rax ,(arithmetic-shift 1 fixnum-shift))))]             
+         (sub rax 2)))]
     [`(zero? ,e0)
-     (let ((c0 (compile-e e0)))
+     (let ((c0 (compile-e e0))
+           (l0 (gensym))
+           (l1 (gensym)))
        `(,@c0
          ,@assert-integer
          (cmp rax 0)
-         (sete al)
-         (movzx rax al)
-         (sal rax ,bool-shift)
-         (or eax ,false-rep)))]         
+         (mov rax #b01) ; #f         
+         (jne ,l0)
+         (mov rax #b11) ; #t
+         ,l0))]
     [`(if ,e0 ,e1 ,e2)
      (let ((c0 (compile-e e0))
            (c1 (compile-e e1))
-           (c2 (compile-e e2)))
-       (match (gen-if-labels)
-         [(list if-f if-x)
-          `(,@c0
-            (cmp rax ,false-rep)
-            (je ,if-f)
-            ,@c1
-            (jmp ,if-x)
-            ,if-f
-            ,@c2
-            ,if-x)]))]))
-
-(define true-rep  #b10011111)
-(define false-rep #b00011111)
-(define fixnum-mask #b11)
-(define fixnum-shift 2)
-(define bool-shift   8)
+           (c2 (compile-e e2))
+           (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))]))
 
 (define assert-integer
   `((mov rbx rax)
-    (and rbx ,fixnum-mask)
+    (and rbx 1)
     (cmp rbx 0)
     (jne err)))

www/notes/extort/main.c

@@ -1,30 +1,29 @@
 #include <stdio.h>
-#include <stdlib.h>
 #include <inttypes.h>
+#include <stdlib.h>
 
-#define fixnum_mask 3
+#define fixnum_mask 1
 #define fixnum_tag 0
-#define fixnum_shift 2
+#define fixnum_shift 1
 
-#define boolean_tag 31
-#define boolean_mask 127
-#define boolean_shift 7
+#define boolean_mask 1
+#define boolean_tag 1
+#define boolean_shift 1
 
 int64_t entry();
 
 int main(int argc, char** argv) {
   int64_t result = entry();
   if ((result & fixnum_mask) == fixnum_tag) {
-    printf("%" PRId64 "\n", result >> fixnum_shift); 
+    printf("%" PRId64 "\n", result >> fixnum_shift);    
   } else if ((result & boolean_mask) == boolean_tag) {
     if (result >> boolean_shift) {
       printf("#t\n");
     } else {
       printf("#f\n");
     }
-  } else {
-    printf("unknown value\n");
   }
+  
   return 0;
 }