~ chicken-core (master) /tests/compiler.scm


    1(define compiler-iters    300)
    2
    3(define (fatal-error . args)
    4  (for-each display args)
    5  (newline)
    6  (exit 1))
    7
    8 (define (call-with-output-file/truncate filename proc)
    9   (call-with-output-file filename proc))
   10
   11(define (run-bench name count ok? run)
   12  (let loop ((i count) (result '(undefined)))
   13    (if (< 0 i)
   14      (loop (- i 1) (run))
   15      result)))
   16
   17(define (run-benchmark name count ok? run-maker . args)
   18  (newline)
   19  (let* ((run (apply run-maker args))
   20         (result (run-bench name count ok? run)))
   21    (if (not (ok? result))
   22      (begin
   23        (display "*** wrong result ***")
   24        (newline)
   25        (display "*** got: ")
   26        (pp result)
   27        (newline))))
   28  (exit 0))
   29;(define integer->char ascii->char)
   30;(define char->integer char->ascii)
   31
   32(define open-input-file* open-input-file)
   33(define (pp-expression expr port) (write expr port) (newline port))
   34(define (write-returning-len obj port) (write obj port) 1)
   35(define (display-returning-len obj port) (display obj port) 1)
   36(define (write-word w port)
   37  (write-char (integer->char (quotient w 256)) port)
   38  (write-char (integer->char (modulo w 256)) port))
   39(define char-nul (integer->char 0))
   40(define char-tab (integer->char 9))
   41(define char-newline (integer->char 10))
   42(define character-encoding char->integer)
   43(define max-character-encoding 255)
   44(define (fatal-err msg arg) (fatal-error msg arg))
   45(define (scheme-global-var name) name)
   46(define (scheme-global-var-ref var) (scheme-global-eval var fatal-err))
   47(define (scheme-global-var-set! var val)
   48  (scheme-global-eval (list 'set! var (list 'quote val)) fatal-err))
   49(define (scheme-global-eval expr err) `(eval ,expr)) ;; eval not needed for test
   50(define (pinpoint-error filename line char) #t)
   51(define file-path-sep #\:)
   52(define file-ext-sep #\.)
   53(define (path-absolute? x)
   54  (and (> (string-length x) 0)
   55       (let ((c (string-ref x 0))) (or (char=? c #\/) (char=? c #\~)))))
   56(define (file-path x)
   57  (let loop1 ((i (string-length x)))
   58    (if (and (> i 0) (not (char=? (string-ref x (- i 1)) file-path-sep)))
   59        (loop1 (- i 1))
   60        (let ((result (make-string i)))
   61          (let loop2 ((j (- i 1)))
   62            (if (< j 0)
   63                result
   64                (begin
   65                  (string-set! result j (string-ref x j))
   66                  (loop2 (- j 1)))))))))
   67(define (file-name x)
   68  (let loop1 ((i (string-length x)))
   69    (if (and (> i 0) (not (char=? (string-ref x (- i 1)) file-path-sep)))
   70        (loop1 (- i 1))
   71        (let ((result (make-string (- (string-length x) i))))
   72          (let loop2 ((j (- (string-length x) 1)))
   73            (if (< j i)
   74                result
   75                (begin
   76                  (string-set! result (- j i) (string-ref x j))
   77                  (loop2 (- j 1)))))))))
   78(define (file-ext x)
   79  (let loop1 ((i (string-length x)))
   80    (if (or (= i 0) (char=? (string-ref x (- i 1)) file-path-sep))
   81        #f
   82        (if (not (char=? (string-ref x (- i 1)) file-ext-sep))
   83            (loop1 (- i 1))
   84            (let ((result (make-string (- (string-length x) i))))
   85              (let loop2 ((j (- (string-length x) 1)))
   86                (if (< j i)
   87                    result
   88                    (begin
   89                      (string-set! result (- j i) (string-ref x j))
   90                      (loop2 (- j 1))))))))))
   91(define (file-root x)
   92  (let loop1 ((i (string-length x)))
   93    (if (or (= i 0) (char=? (string-ref x (- i 1)) file-path-sep))
   94        x
   95        (if (not (char=? (string-ref x (- i 1)) file-ext-sep))
   96            (loop1 (- i 1))
   97            (let ((result (make-string (- i 1))))
   98              (let loop2 ((j (- i 2)))
   99                (if (< j 0)
  100                    result
  101                    (begin
  102                      (string-set! result j (string-ref x j))
  103                      (loop2 (- j 1))))))))))
  104(define (make-counter next limit limit-error)
  105  (lambda ()
  106    (if (< next limit)
  107        (let ((result next)) (set! next (+ next 1)) result)
  108        (limit-error))))
  109(define (pos-in-list x l)
  110  (let loop ((l l) (i 0))
  111    (cond ((not (pair? l)) #f)
  112          ((eq? (car l) x) i)
  113          (else (loop (cdr l) (+ i 1))))))
  114(define (string-pos-in-list x l)
  115  (let loop ((l l) (i 0))
  116    (cond ((not (pair? l)) #f)
  117          ((string=? (car l) x) i)
  118          (else (loop (cdr l) (+ i 1))))))
  119(define (nth-after l n)
  120  (let loop ((l l) (n n)) (if (> n 0) (loop (cdr l) (- n 1)) l)))
  121(define (pair-up l1 l2)
  122  (define (pair l1 l2)
  123    (if (pair? l1)
  124        (cons (cons (car l1) (car l2)) (pair (cdr l1) (cdr l2)))
  125        '()))
  126  (pair l1 l2))
  127(define (my-last-pair l)
  128  (let loop ((l l)) (if (pair? (cdr l)) (loop (cdr l)) l)))
  129(define (sort-list l <?)
  130  (define (mergesort l)
  131    (define (merge l1 l2)
  132      (cond ((null? l1) l2)
  133            ((null? l2) l1)
  134            (else
  135             (let ((e1 (car l1)) (e2 (car l2)))
  136               (if (<? e1 e2)
  137                   (cons e1 (merge (cdr l1) l2))
  138                   (cons e2 (merge l1 (cdr l2))))))))
  139    (define (split l)
  140      (if (or (null? l) (null? (cdr l))) l (cons (car l) (split (cddr l)))))
  141    (if (or (null? l) (null? (cdr l)))
  142        l
  143        (let* ((l1 (mergesort (split l))) (l2 (mergesort (split (cdr l)))))
  144          (merge l1 l2))))
  145  (mergesort l))
  146(define (lst->vector l)
  147  (let* ((n (length l)) (v (make-vector n)))
  148    (let loop ((l l) (i 0))
  149      (if (pair? l)
  150          (begin (vector-set! v i (car l)) (loop (cdr l) (+ i 1)))
  151          v))))
  152(define (vector->lst v)
  153  (let loop ((l '()) (i (- (vector-length v) 1)))
  154    (if (< i 0) l (loop (cons (vector-ref v i) l) (- i 1)))))
  155(define (lst->string l)
  156  (let* ((n (length l)) (s (make-string n)))
  157    (let loop ((l l) (i 0))
  158      (if (pair? l)
  159          (begin (string-set! s i (car l)) (loop (cdr l) (+ i 1)))
  160          s))))
  161(define (string->lst s)
  162  (let loop ((l '()) (i (- (string-length s) 1)))
  163    (if (< i 0) l (loop (cons (string-ref s i) l) (- i 1)))))
  164(define (with-exception-handling proc)
  165  (let ((old-exception-handler throw-to-exception-handler))
  166    (let ((val (call-with-current-continuation
  167                (lambda (cont)
  168                  (set! throw-to-exception-handler cont)
  169                  (proc)))))
  170      (set! throw-to-exception-handler old-exception-handler)
  171      val)))
  172(define (throw-to-exception-handler val)
  173  (fatal-err "Internal error, no exception handler at this point" val))
  174(define (compiler-error msg . args)
  175  (newline)
  176  (display "*** ERROR -- ")
  177  (display msg)
  178  (for-each (lambda (x) (display " ") (write x)) args)
  179  (newline)
  180  (compiler-abort))
  181(define (compiler-user-error loc msg . args)
  182  (newline)
  183  (display "*** ERROR -- In ")
  184  (locat-show loc)
  185  (newline)
  186  (display "*** ")
  187  (display msg)
  188  (for-each (lambda (x) (display " ") (write x)) args)
  189  (newline)
  190  (compiler-abort))
  191(define (compiler-internal-error msg . args)
  192  (newline)
  193  (display "*** ERROR -- Compiler internal error detected")
  194  (newline)
  195  (display "*** in procedure ")
  196  (display msg)
  197  (for-each (lambda (x) (display " ") (write x)) args)
  198  (newline)
  199  (compiler-abort))
  200(define (compiler-limitation-error msg . args)
  201  (newline)
  202  (display "*** ERROR -- Compiler limit reached")
  203  (newline)
  204  (display "*** ")
  205  (display msg)
  206  (for-each (lambda (x) (display " ") (write x)) args)
  207  (newline)
  208  (compiler-abort))
  209(define (compiler-abort) (throw-to-exception-handler #f))
  210(define (make-gnode label edges) (vector label edges))
  211(define (gnode-label x) (vector-ref x 0))
  212(define (gnode-edges x) (vector-ref x 1))
  213(define (transitive-closure graph)
  214  (define changed? #f)
  215  (define (closure edges)
  216    (list->set
  217     (set-union
  218      edges
  219      (apply set-union
  220             (map (lambda (label) (gnode-edges (gnode-find label graph)))
  221                  (set->list edges))))))
  222  (let ((new-graph
  223         (set-map (lambda (x)
  224                    (let ((new-edges (closure (gnode-edges x))))
  225                      (if (not (set-equal? new-edges (gnode-edges x)))
  226                          (set! changed? #t))
  227                      (make-gnode (gnode-label x) new-edges)))
  228                  graph)))
  229    (if changed? (transitive-closure new-graph) new-graph)))
  230(define (gnode-find label graph)
  231  (define (find label l)
  232    (cond ((null? l) #f)
  233          ((eq? (gnode-label (car l)) label) (car l))
  234          (else (find label (cdr l)))))
  235  (find label (set->list graph)))
  236(define (topological-sort graph)
  237  (if (set-empty? graph)
  238      '()
  239      (let ((to-remove (or (remove-no-edges graph) (remove-cycle graph))))
  240        (let ((labels (set-map gnode-label to-remove)))
  241          (cons labels
  242                (topological-sort
  243                 (set-map (lambda (x)
  244                            (make-gnode
  245                             (gnode-label x)
  246                             (set-difference (gnode-edges x) labels)))
  247                          (set-difference graph to-remove))))))))
  248(define (remove-no-edges graph)
  249  (let ((nodes-with-no-edges
  250         (set-keep (lambda (x) (set-empty? (gnode-edges x))) graph)))
  251    (if (set-empty? nodes-with-no-edges) #f nodes-with-no-edges)))
  252(define (remove-cycle graph)
  253  (define (remove l)
  254    (let ((edges (gnode-edges (car l))))
  255      (define (equal-edges? x) (set-equal? (gnode-edges x) edges))
  256      (define (member-edges? x) (set-member? (gnode-label x) edges))
  257      (if (set-member? (gnode-label (car l)) edges)
  258          (let ((edge-graph (set-keep member-edges? graph)))
  259            (if (set-every? equal-edges? edge-graph)
  260                edge-graph
  261                (remove (cdr l))))
  262          (remove (cdr l)))))
  263  (remove (set->list graph)))
  264(define (list->set list) list)
  265(define (set->list set) set)
  266(define (set-empty) '())
  267(define (set-empty? set) (null? set))
  268(define (set-member? x set) (memq x set))
  269(define (set-singleton x) (list x))
  270(define (set-adjoin set x) (if (memq x set) set (cons x set)))
  271(define (set-remove set x)
  272  (cond ((null? set) '())
  273        ((eq? (car set) x) (cdr set))
  274        (else (cons (car set) (set-remove (cdr set) x)))))
  275(define (set-equal? s1 s2)
  276  (cond ((null? s1) (null? s2))
  277        ((memq (car s1) s2) (set-equal? (cdr s1) (set-remove s2 (car s1))))
  278        (else #f)))
  279(define (set-difference set . other-sets)
  280  (define (difference s1 s2)
  281    (cond ((null? s1) '())
  282          ((memq (car s1) s2) (difference (cdr s1) s2))
  283          (else (cons (car s1) (difference (cdr s1) s2)))))
  284  (n-ary difference set other-sets))
  285(define (set-union . sets)
  286  (define (union s1 s2)
  287    (cond ((null? s1) s2)
  288          ((memq (car s1) s2) (union (cdr s1) s2))
  289          (else (cons (car s1) (union (cdr s1) s2)))))
  290  (n-ary union '() sets))
  291(define (set-intersection set . other-sets)
  292  (define (intersection s1 s2)
  293    (cond ((null? s1) '())
  294          ((memq (car s1) s2) (cons (car s1) (intersection (cdr s1) s2)))
  295          (else (intersection (cdr s1) s2))))
  296  (n-ary intersection set other-sets))
  297(define (n-ary function first rest)
  298  (if (null? rest)
  299      first
  300      (n-ary function (function first (car rest)) (cdr rest))))
  301(define (set-keep keep? set)
  302  (cond ((null? set) '())
  303        ((keep? (car set)) (cons (car set) (set-keep keep? (cdr set))))
  304        (else (set-keep keep? (cdr set)))))
  305(define (set-every? pred? set)
  306  (or (null? set) (and (pred? (car set)) (set-every? pred? (cdr set)))))
  307(define (set-map proc set)
  308  (if (null? set) '() (cons (proc (car set)) (set-map proc (cdr set)))))
  309(define (list->queue list)
  310  (cons list (if (pair? list) (my-last-pair list) '())))
  311(define (queue->list queue) (car queue))
  312(define (queue-empty) (cons '() '()))
  313(define (queue-empty? queue) (null? (car queue)))
  314(define (queue-get! queue)
  315  (if (null? (car queue))
  316      (compiler-internal-error "queue-get!, queue is empty")
  317      (let ((x (caar queue)))
  318        (set-car! queue (cdar queue))
  319        (if (null? (car queue)) (set-cdr! queue '()))
  320        x)))
  321(define (queue-put! queue x)
  322  (let ((entry (cons x '())))
  323    (if (null? (car queue))
  324        (set-car! queue entry)
  325        (set-cdr! (cdr queue) entry))
  326    (set-cdr! queue entry)
  327    x))
  328(define (string->canonical-symbol str)
  329  (let ((len (string-length str)))
  330    (let loop ((str str) (s (make-string len)) (i (- len 1)))
  331      (if (>= i 0)
  332          (begin
  333            (string-set! s i (char-downcase (string-ref str i)))
  334            (loop str s (- i 1)))
  335          (string->symbol s)))))
  336(define quote-sym (string->canonical-symbol "QUOTE"))
  337(define quasiquote-sym (string->canonical-symbol "QUASIQUOTE"))
  338(define unquote-sym (string->canonical-symbol "UNQUOTE"))
  339(define unquote-splicing-sym (string->canonical-symbol "UNQUOTE-SPLICING"))
  340(define lambda-sym (string->canonical-symbol "LAMBDA"))
  341(define if-sym (string->canonical-symbol "IF"))
  342(define set!-sym (string->canonical-symbol "SET!"))
  343(define cond-sym (string->canonical-symbol "COND"))
  344(define =>-sym (string->canonical-symbol "=>"))
  345(define else-sym (string->canonical-symbol "ELSE"))
  346(define and-sym (string->canonical-symbol "AND"))
  347(define or-sym (string->canonical-symbol "OR"))
  348(define case-sym (string->canonical-symbol "CASE"))
  349(define let-sym (string->canonical-symbol "LET"))
  350(define let*-sym (string->canonical-symbol "LET*"))
  351(define letrec-sym (string->canonical-symbol "LETREC"))
  352(define begin-sym (string->canonical-symbol "BEGIN"))
  353(define do-sym (string->canonical-symbol "DO"))
  354(define define-sym (string->canonical-symbol "DEFINE"))
  355(define delay-sym (string->canonical-symbol "DELAY"))
  356(define future-sym (string->canonical-symbol "FUTURE"))
  357(define **define-macro-sym (string->canonical-symbol "DEFINE-MACRO"))
  358(define **declare-sym (string->canonical-symbol "DECLARE"))
  359(define **include-sym (string->canonical-symbol "INCLUDE"))
  360(define not-sym (string->canonical-symbol "NOT"))
  361(define **c-declaration-sym (string->canonical-symbol "C-DECLARATION"))
  362(define **c-init-sym (string->canonical-symbol "C-INIT"))
  363(define **c-procedure-sym (string->canonical-symbol "C-PROCEDURE"))
  364(define void-sym (string->canonical-symbol "VOID"))
  365(define char-sym (string->canonical-symbol "CHAR"))
  366(define signed-char-sym (string->canonical-symbol "SIGNED-CHAR"))
  367(define unsigned-char-sym (string->canonical-symbol "UNSIGNED-CHAR"))
  368(define short-sym (string->canonical-symbol "SHORT"))
  369(define unsigned-short-sym (string->canonical-symbol "UNSIGNED-SHORT"))
  370(define int-sym (string->canonical-symbol "INT"))
  371(define unsigned-int-sym (string->canonical-symbol "UNSIGNED-INT"))
  372(define long-sym (string->canonical-symbol "LONG"))
  373(define unsigned-long-sym (string->canonical-symbol "UNSIGNED-LONG"))
  374(define float-sym (string->canonical-symbol "FLOAT"))
  375(define double-sym (string->canonical-symbol "DOUBLE"))
  376(define pointer-sym (string->canonical-symbol "POINTER"))
  377(define boolean-sym (string->canonical-symbol "BOOLEAN"))
  378(define string-sym (string->canonical-symbol "STRING"))
  379(define scheme-object-sym (string->canonical-symbol "SCHEME-OBJECT"))
  380(define c-id-prefix "___")
  381(define false-object (if (eq? '() #f) (string->symbol "#f") #f))
  382(define (false-object? obj) (eq? obj false-object))
  383(define undef-object (string->symbol "#[undefined]"))
  384(define (undef-object? obj) (eq? obj undef-object))
  385(define (symbol-object? obj)
  386  (and (not (false-object? obj)) (not (undef-object? obj)) (symbol? obj)))
  387(define scm-file-exts '("scm" #f))
  388(define compiler-version "2.2.2")
  389(define (open-sf filename)
  390  (define (open-err) (compiler-error "Can't find file" filename))
  391  (if (not (file-ext filename))
  392      (let loop ((exts scm-file-exts))
  393        (if (pair? exts)
  394            (let* ((ext (car exts))
  395                   (full-name
  396                    (if ext (string-append filename "." ext) filename))
  397                   (port (open-input-file* full-name)))
  398              (if port (vector port full-name 0 1 0) (loop (cdr exts))))
  399            (open-err)))
  400      (let ((port (open-input-file* filename)))
  401        (if port (vector port filename 0 1 0) (open-err)))))
  402(define (close-sf sf) (close-input-port (vector-ref sf 0)))
  403(define (sf-read-char sf)
  404  (let ((c (read-char (vector-ref sf 0))))
  405    (cond ((eof-object? c))
  406          ((char=? c char-newline)
  407           (vector-set! sf 3 (+ (vector-ref sf 3) 1))
  408           (vector-set! sf 4 0))
  409          (else (vector-set! sf 4 (+ (vector-ref sf 4) 1))))
  410    c))
  411(define (sf-peek-char sf) (peek-char (vector-ref sf 0)))
  412(define (sf-read-error sf msg . args)
  413  (apply compiler-user-error
  414         (cons (sf->locat sf)
  415               (cons (string-append "Read error -- " msg) args))))
  416(define (sf->locat sf)
  417  (vector 'file
  418          (vector-ref sf 1)
  419          (vector-ref sf 2)
  420          (vector-ref sf 3)
  421          (vector-ref sf 4)))
  422(define (expr->locat expr source) (vector 'expr expr source))
  423(define (locat-show loc)
  424  (if loc
  425      (case (vector-ref loc 0)
  426        ((file)
  427         (if (pinpoint-error
  428              (vector-ref loc 1)
  429              (vector-ref loc 3)
  430              (vector-ref loc 4))
  431             (begin
  432               (display "file \"")
  433               (display (vector-ref loc 1))
  434               (display "\", line ")
  435               (display (vector-ref loc 3))
  436               (display ", character ")
  437               (display (vector-ref loc 4)))))
  438        ((expr)
  439         (display "expression ")
  440         (write (vector-ref loc 1))
  441         (if (vector-ref loc 2)
  442             (begin
  443               (display " ")
  444               (locat-show (source-locat (vector-ref loc 2))))))
  445        (else (compiler-internal-error "locat-show, unknown location tag")))
  446      (display "unknown location")))
  447(define (locat-filename loc)
  448  (if loc
  449      (case (vector-ref loc 0)
  450        ((file) (vector-ref loc 1))
  451        ((expr)
  452         (let ((source (vector-ref loc 2)))
  453           (if source (locat-filename (source-locat source)) "")))
  454        (else
  455         (compiler-internal-error "locat-filename, unknown location tag")))
  456      ""))
  457(define (make-source code locat) (vector code locat))
  458(define (source-code x) (vector-ref x 0))
  459(define (source-code-set! x y) (vector-set! x 0 y) x)
  460(define (source-locat x) (vector-ref x 1))
  461(define (expression->source expr source)
  462  (define (expr->source x)
  463    (make-source
  464     (cond ((pair? x) (list->source x))
  465           ((vector? x) (vector->source x))
  466           ((symbol-object? x) (string->canonical-symbol (symbol->string x)))
  467           (else x))
  468     (expr->locat x source)))
  469  (define (list->source l)
  470    (cond ((pair? l) (cons (expr->source (car l)) (list->source (cdr l))))
  471          ((null? l) '())
  472          (else (expr->source l))))
  473  (define (vector->source v)
  474    (let* ((len (vector-length v)) (x (make-vector len)))
  475      (let loop ((i (- len 1)))
  476        (if (>= i 0)
  477            (begin
  478              (vector-set! x i (expr->source (vector-ref v i)))
  479              (loop (- i 1)))))
  480      x))
  481  (expr->source expr))
  482(define (source->expression source)
  483  (define (list->expression l)
  484    (cond ((pair? l)
  485           (cons (source->expression (car l)) (list->expression (cdr l))))
  486          ((null? l) '())
  487          (else (source->expression l))))
  488  (define (vector->expression v)
  489    (let* ((len (vector-length v)) (x (make-vector len)))
  490      (let loop ((i (- len 1)))
  491        (if (>= i 0)
  492            (begin
  493              (vector-set! x i (source->expression (vector-ref v i)))
  494              (loop (- i 1)))))
  495      x))
  496  (let ((code (source-code source)))
  497    (cond ((pair? code) (list->expression code))
  498          ((vector? code) (vector->expression code))
  499          (else code))))
  500(define (file->sources filename info-port)
  501  (if info-port
  502      (begin
  503        (display "(reading \"" info-port)
  504        (display filename info-port)
  505        (display "\"" info-port)))
  506  (let ((sf (open-sf filename)))
  507    (define (read-sources)
  508      (let ((source (read-source sf)))
  509        (if (not (eof-object? source))
  510            (begin
  511              (if info-port (display "." info-port))
  512              (cons source (read-sources)))
  513            '())))
  514    (let ((sources (read-sources)))
  515      (if info-port (display ")" info-port))
  516      (close-sf sf)
  517      sources)))
  518(define (file->sources* filename info-port loc)
  519  (file->sources
  520   (if (path-absolute? filename)
  521       filename
  522       (string-append (file-path (locat-filename loc)) filename))
  523   info-port))
  524(define (read-source sf)
  525  (define (read-char*)
  526    (let ((c (sf-read-char sf)))
  527      (if (eof-object? c)
  528          (sf-read-error sf "Premature end of file encountered")
  529          c)))
  530  (define (read-non-whitespace-char)
  531    (let ((c (read-char*)))
  532      (cond ((< 0 (vector-ref read-table (char->integer c)))
  533             (read-non-whitespace-char))
  534            ((char=? c #\;)
  535             (let loop ()
  536               (if (not (char=? (read-char*) char-newline))
  537                   (loop)
  538                   (read-non-whitespace-char))))
  539            (else c))))
  540  (define (delimiter? c)
  541    (or (eof-object? c) (not (= (vector-ref read-table (char->integer c)) 0))))
  542  (define (read-list first)
  543    (let ((result (cons first '())))
  544      (let loop ((end result))
  545        (let ((c (read-non-whitespace-char)))
  546          (cond ((char=? c #\)))
  547                ((and (char=? c #\.) (delimiter? (sf-peek-char sf)))
  548                 (let ((x (read-source sf)))
  549                   (if (char=? (read-non-whitespace-char) #\))
  550                       (set-cdr! end x)
  551                       (sf-read-error sf "')' expected"))))
  552                (else
  553                 (let ((tail (cons (rd* c) '())))
  554                   (set-cdr! end tail)
  555                   (loop tail))))))
  556      result))
  557  (define (read-vector)
  558    (define (loop i)
  559      (let ((c (read-non-whitespace-char)))
  560        (if (char=? c #\))
  561            (make-vector i '())
  562            (let* ((x (rd* c)) (v (loop (+ i 1)))) (vector-set! v i x) v))))
  563    (loop 0))
  564  (define (read-string)
  565    (define (loop i)
  566      (let ((c (read-char*)))
  567        (cond ((char=? c #\") (make-string i #\space))
  568              ((char=? c #\\)
  569               (let* ((c (read-char*)) (s (loop (+ i 1))))
  570                 (string-set! s i c)
  571                 s))
  572              (else (let ((s (loop (+ i 1)))) (string-set! s i c) s)))))
  573    (loop 0))
  574  (define (read-symbol/number-string i)
  575    (if (delimiter? (sf-peek-char sf))
  576        (make-string i #\space)
  577        (let* ((c (sf-read-char sf)) (s (read-symbol/number-string (+ i 1))))
  578          (string-set! s i (char-downcase c))
  579          s)))
  580  (define (read-symbol/number c)
  581    (let ((s (read-symbol/number-string 1)))
  582      (string-set! s 0 (char-downcase c))
  583      (or (string->number s 10) (string->canonical-symbol s))))
  584  (define (read-prefixed-number c)
  585    (let ((s (read-symbol/number-string 2)))
  586      (string-set! s 0 #\#)
  587      (string-set! s 1 c)
  588      (string->number s 10)))
  589  (define (read-special-symbol)
  590    (let ((s (read-symbol/number-string 2)))
  591      (string-set! s 0 #\#)
  592      (string-set! s 1 #\#)
  593      (string->canonical-symbol s)))
  594  (define (rd c)
  595    (cond ((eof-object? c) c)
  596          ((< 0 (vector-ref read-table (char->integer c)))
  597           (rd (sf-read-char sf)))
  598          ((char=? c #\;)
  599           (let loop ()
  600             (let ((c (sf-read-char sf)))
  601               (cond ((eof-object? c) c)
  602                     ((char=? c char-newline) (rd (sf-read-char sf)))
  603                     (else (loop))))))
  604          (else (rd* c))))
  605  (define (rd* c)
  606    (let ((source (make-source #f (sf->locat sf))))
  607      (source-code-set!
  608       source
  609       (cond ((char=? c #\()
  610              (let ((x (read-non-whitespace-char)))
  611                (if (char=? x #\)) '() (read-list (rd* x)))))
  612             ((char=? c #\#)
  613              (let ((c (char-downcase (sf-read-char sf))))
  614                (cond ((char=? c #\() (read-vector))
  615                      ((char=? c #\f) false-object)
  616                      ((char=? c #\t) #t)
  617                      ((char=? c #\\)
  618                       (let ((c (read-char*)))
  619                         (if (or (not (char-alphabetic? c))
  620                                 (delimiter? (sf-peek-char sf)))
  621                             c
  622                             (let ((name (read-symbol/number c)))
  623                               (let ((x (assq name named-char-table)))
  624                                 (if x
  625                                     (cdr x)
  626                                     (sf-read-error
  627                                      sf
  628                                      "Unknown character name"
  629                                      name)))))))
  630                      ((char=? c #\#) (read-special-symbol))
  631                      (else
  632                       (let ((num (read-prefixed-number c)))
  633                         (or num
  634                             (sf-read-error
  635                              sf
  636                              "Unknown '#' read macro"
  637                              c)))))))
  638             ((char=? c #\") (read-string))
  639             ((char=? c #\')
  640              (list (make-source quote-sym (sf->locat sf)) (read-source sf)))
  641             ((char=? c #\`)
  642              (list (make-source quasiquote-sym (sf->locat sf))
  643                    (read-source sf)))
  644             ((char=? c #\,)
  645              (if (char=? (sf-peek-char sf) #\@)
  646                  (let ((x (make-source unquote-splicing-sym (sf->locat sf))))
  647                    (sf-read-char sf)
  648                    (list x (read-source sf)))
  649                  (list (make-source unquote-sym (sf->locat sf))
  650                        (read-source sf))))
  651             ((char=? c #\)) (sf-read-error sf "Misplaced ')'"))
  652             ((or (char=? c #\[) (char=? c #\]) (char=? c #\{) (char=? c #\}))
  653              (sf-read-error sf "Illegal character" c))
  654             (else
  655              (if (char=? c #\.)
  656                  (if (delimiter? (sf-peek-char sf))
  657                      (sf-read-error sf "Misplaced '.'")))
  658              (read-symbol/number c))))))
  659  (rd (sf-read-char sf)))
  660(define named-char-table
  661  (list (cons (string->canonical-symbol "NUL") char-nul)
  662        (cons (string->canonical-symbol "TAB") char-tab)
  663        (cons (string->canonical-symbol "NEWLINE") char-newline)
  664        (cons (string->canonical-symbol "SPACE") #\space)))
  665(define read-table
  666  (let ((rt (make-vector (+ max-character-encoding 1) 0)))
  667    (vector-set! rt (char->integer char-tab) 1)
  668    (vector-set! rt (char->integer char-newline) 1)
  669    (vector-set! rt (char->integer #\space) 1)
  670    (vector-set! rt (char->integer #\;) -1)
  671    (vector-set! rt (char->integer #\() -1)
  672    (vector-set! rt (char->integer #\)) -1)
  673    (vector-set! rt (char->integer #\") -1)
  674    (vector-set! rt (char->integer #\') -1)
  675    (vector-set! rt (char->integer #\`) -1)
  676    rt))
  677(define (make-var name bound refs sets source)
  678  (vector var-tag name bound refs sets source #f))
  679(define (var? x)
  680  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) var-tag)))
  681(define (var-name x) (vector-ref x 1))
  682(define (var-bound x) (vector-ref x 2))
  683(define (var-refs x) (vector-ref x 3))
  684(define (var-sets x) (vector-ref x 4))
  685(define (var-source x) (vector-ref x 5))
  686(define (var-info x) (vector-ref x 6))
  687(define (var-name-set! x y) (vector-set! x 1 y))
  688(define (var-bound-set! x y) (vector-set! x 2 y))
  689(define (var-refs-set! x y) (vector-set! x 3 y))
  690(define (var-sets-set! x y) (vector-set! x 4 y))
  691(define (var-source-set! x y) (vector-set! x 5 y))
  692(define (var-info-set! x y) (vector-set! x 6 y))
  693(define var-tag (list 'var-tag))
  694(define (var-copy var)
  695  (make-var (var-name var) #t (set-empty) (set-empty) (var-source var)))
  696(define (make-temp-var name) (make-var name #t (set-empty) (set-empty) #f))
  697(define (temp-var? var) (eq? (var-bound var) #t))
  698(define ret-var (make-temp-var 'ret))
  699(define ret-var-set (set-singleton ret-var))
  700(define closure-env-var (make-temp-var 'closure-env))
  701(define empty-var (make-temp-var #f))
  702(define make-global-environment #f)
  703(set! make-global-environment (lambda () (env-frame #f '())))
  704(define (env-frame env vars) (vector (cons vars #f) '() '() env))
  705(define (env-new-var! env name source)
  706  (let* ((glob (not (env-parent-ref env)))
  707         (var (make-var name (not glob) (set-empty) (set-empty) source)))
  708    (env-vars-set! env (cons var (env-vars-ref env)))
  709    var))
  710(define (env-macro env name def)
  711  (let ((name* (if (full-name? name)
  712                   name
  713                   (let ((prefix (env-namespace-prefix env name)))
  714                     (if prefix (make-full-name prefix name) name)))))
  715    (vector (vector-ref env 0)
  716            (cons (cons name* def) (env-macros-ref env))
  717            (env-decls-ref env)
  718            (env-parent-ref env))))
  719(define (env-declare env decl)
  720  (vector (vector-ref env 0)
  721          (env-macros-ref env)
  722          (cons decl (env-decls-ref env))
  723          (env-parent-ref env)))
  724(define (env-vars-ref env) (car (vector-ref env 0)))
  725(define (env-vars-set! env vars) (set-car! (vector-ref env 0) vars))
  726(define (env-macros-ref env) (vector-ref env 1))
  727(define (env-decls-ref env) (vector-ref env 2))
  728(define (env-parent-ref env) (vector-ref env 3))
  729(define (env-namespace-prefix env name)
  730  (let loop ((decls (env-decls-ref env)))
  731    (if (pair? decls)
  732        (let ((decl (car decls)))
  733          (if (eq? (car decl) namespace-sym)
  734              (let ((syms (cddr decl)))
  735                (if (or (null? syms) (memq name syms))
  736                    (cadr decl)
  737                    (loop (cdr decls))))
  738              (loop (cdr decls))))
  739        #f)))
  740(define (env-lookup env name stop-at-first-frame? proc)
  741  (define (search env name full?)
  742    (if full?
  743        (search* env name full?)
  744        (let ((prefix (env-namespace-prefix env name)))
  745          (if prefix
  746              (search* env (make-full-name prefix name) #t)
  747              (search* env name full?)))))
  748  (define (search* env name full?)
  749    (define (search-macros macros)
  750      (if (pair? macros)
  751          (let ((m (car macros)))
  752            (if (eq? (car m) name)
  753                (proc env name (cdr m))
  754                (search-macros (cdr macros))))
  755          (search-vars (env-vars-ref env))))
  756    (define (search-vars vars)
  757      (if (pair? vars)
  758          (let ((v (car vars)))
  759            (if (eq? (var-name v) name)
  760                (proc env name v)
  761                (search-vars (cdr vars))))
  762          (let ((env* (env-parent-ref env)))
  763            (if (or stop-at-first-frame? (not env*))
  764                (proc env name #f)
  765                (search env* name full?)))))
  766    (search-macros (env-macros-ref env)))
  767  (search env name (full-name? name)))
  768(define (valid-prefix? str)
  769  (let ((l (string-length str)))
  770    (or (= l 0) (and (>= l 2) (char=? (string-ref str (- l 1)) #\#)))))
  771(define (full-name? sym)
  772  (let ((str (symbol->string sym)))
  773    (let loop ((i (- (string-length str) 1)))
  774      (if (< i 0) #f (if (char=? (string-ref str i) #\#) #t (loop (- i 1)))))))
  775(define (make-full-name prefix sym)
  776  (if (= (string-length prefix) 0)
  777      sym
  778      (string->canonical-symbol (string-append prefix (symbol->string sym)))))
  779(define (env-lookup-var env name source)
  780  (env-lookup
  781   env
  782   name
  783   #f
  784   (lambda (env name x)
  785     (if x
  786         (if (var? x)
  787             x
  788             (compiler-internal-error
  789              "env-lookup-var, name is that of a macro"
  790              name))
  791         (env-new-var! env name source)))))
  792(define (env-define-var env name source)
  793  (env-lookup
  794   env
  795   name
  796   #t
  797   (lambda (env name x)
  798     (if x
  799         (if (var? x)
  800             (pt-syntax-error source "Duplicate definition of a variable")
  801             (compiler-internal-error
  802              "env-define-var, name is that of a macro"
  803              name))
  804         (env-new-var! env name source)))))
  805(define (env-lookup-global-var env name)
  806  (let ((env* (env-global-env env)))
  807    (define (search-vars vars)
  808      (if (pair? vars)
  809          (let ((v (car vars)))
  810            (if (eq? (var-name v) name) v (search-vars (cdr vars))))
  811          (env-new-var! env* name #f)))
  812    (search-vars (env-vars-ref env*))))
  813(define (env-global-variables env) (env-vars-ref (env-global-env env)))
  814(define (env-global-env env)
  815  (let loop ((env env))
  816    (let ((env* (env-parent-ref env))) (if env* (loop env*) env))))
  817(define (env-lookup-macro env name)
  818  (env-lookup
  819   env
  820   name
  821   #f
  822   (lambda (env name x) (if (or (not x) (var? x)) #f x))))
  823(define (env-declarations env) env)
  824(define flag-declarations '())
  825(define parameterized-declarations '())
  826(define boolean-declarations '())
  827(define namable-declarations '())
  828(define namable-boolean-declarations '())
  829(define namable-string-declarations '())
  830(define (define-flag-decl name type)
  831  (set! flag-declarations (cons (cons name type) flag-declarations))
  832  '())
  833(define (define-parameterized-decl name)
  834  (set! parameterized-declarations (cons name parameterized-declarations))
  835  '())
  836(define (define-boolean-decl name)
  837  (set! boolean-declarations (cons name boolean-declarations))
  838  '())
  839(define (define-namable-decl name type)
  840  (set! namable-declarations (cons (cons name type) namable-declarations))
  841  '())
  842(define (define-namable-boolean-decl name)
  843  (set! namable-boolean-declarations (cons name namable-boolean-declarations))
  844  '())
  845(define (define-namable-string-decl name)
  846  (set! namable-string-declarations (cons name namable-string-declarations))
  847  '())
  848(define (flag-decl source type val) (list type val))
  849(define (parameterized-decl source id parm) (list id parm))
  850(define (boolean-decl source id pos) (list id pos))
  851(define (namable-decl source type val names) (cons type (cons val names)))
  852(define (namable-boolean-decl source id pos names) (cons id (cons pos names)))
  853(define (namable-string-decl source id str names)
  854  (if (and (eq? id namespace-sym) (not (valid-prefix? str)))
  855      (pt-syntax-error source "Illegal namespace"))
  856  (cons id (cons str names)))
  857(define (declaration-value name element default decls)
  858  (if (not decls)
  859      default
  860      (let loop ((l (env-decls-ref decls)))
  861        (if (pair? l)
  862            (let ((d (car l)))
  863              (if (and (eq? (car d) name)
  864                       (or (null? (cddr d)) (memq element (cddr d))))
  865                  (cadr d)
  866                  (loop (cdr l))))
  867            (declaration-value name element default (env-parent-ref decls))))))
  868(define namespace-sym (string->canonical-symbol "NAMESPACE"))
  869(define-namable-string-decl namespace-sym)
  870(define (node-parent x) (vector-ref x 1))
  871(define (node-children x) (vector-ref x 2))
  872(define (node-fv x) (vector-ref x 3))
  873(define (node-decl x) (vector-ref x 4))
  874(define (node-source x) (vector-ref x 5))
  875(define (node-parent-set! x y) (vector-set! x 1 y))
  876(define (node-fv-set! x y) (vector-set! x 3 y))
  877(define (node-decl-set! x y) (vector-set! x 4 y))
  878(define (node-source-set! x y) (vector-set! x 5 y))
  879(define (node-children-set! x y)
  880  (vector-set! x 2 y)
  881  (for-each (lambda (child) (node-parent-set! child x)) y)
  882  (node-fv-invalidate! x))
  883(define (node-fv-invalidate! x)
  884  (let loop ((node x))
  885    (if node (begin (node-fv-set! node #t) (loop (node-parent node))))))
  886(define (make-cst parent children fv decl source val)
  887  (vector cst-tag parent children fv decl source val))
  888(define (cst? x)
  889  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) cst-tag)))
  890(define (cst-val x) (vector-ref x 6))
  891(define (cst-val-set! x y) (vector-set! x 6 y))
  892(define cst-tag (list 'cst-tag))
  893(define (make-ref parent children fv decl source var)
  894  (vector ref-tag parent children fv decl source var))
  895(define (ref? x)
  896  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) ref-tag)))
  897(define (ref-var x) (vector-ref x 6))
  898(define (ref-var-set! x y) (vector-set! x 6 y))
  899(define ref-tag (list 'ref-tag))
  900(define (make-set parent children fv decl source var)
  901  (vector set-tag parent children fv decl source var))
  902(define (set? x)
  903  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) set-tag)))
  904(define (set-var x) (vector-ref x 6))
  905(define (set-var-set! x y) (vector-set! x 6 y))
  906(define set-tag (list 'set-tag))
  907(define (make-def parent children fv decl source var)
  908  (vector def-tag parent children fv decl source var))
  909(define (def? x)
  910  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) def-tag)))
  911(define (def-var x) (vector-ref x 6))
  912(define (def-var-set! x y) (vector-set! x 6 y))
  913(define def-tag (list 'def-tag))
  914(define (make-tst parent children fv decl source)
  915  (vector tst-tag parent children fv decl source))
  916(define (tst? x)
  917  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) tst-tag)))
  918(define tst-tag (list 'tst-tag))
  919(define (make-conj parent children fv decl source)
  920  (vector conj-tag parent children fv decl source))
  921(define (conj? x)
  922  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) conj-tag)))
  923(define conj-tag (list 'conj-tag))
  924(define (make-disj parent children fv decl source)
  925  (vector disj-tag parent children fv decl source))
  926(define (disj? x)
  927  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) disj-tag)))
  928(define disj-tag (list 'disj-tag))
  929(define (make-prc parent children fv decl source name min rest parms)
  930  (vector prc-tag parent children fv decl source name min rest parms))
  931(define (prc? x)
  932  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) prc-tag)))
  933(define (prc-name x) (vector-ref x 6))
  934(define (prc-min x) (vector-ref x 7))
  935(define (prc-rest x) (vector-ref x 8))
  936(define (prc-parms x) (vector-ref x 9))
  937(define (prc-name-set! x y) (vector-set! x 6 y))
  938(define (prc-min-set! x y) (vector-set! x 7 y))
  939(define (prc-rest-set! x y) (vector-set! x 8 y))
  940(define (prc-parms-set! x y) (vector-set! x 9 y))
  941(define prc-tag (list 'prc-tag))
  942(define (make-app parent children fv decl source)
  943  (vector app-tag parent children fv decl source))
  944(define (app? x)
  945  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) app-tag)))
  946(define app-tag (list 'app-tag))
  947(define (make-fut parent children fv decl source)
  948  (vector fut-tag parent children fv decl source))
  949(define (fut? x)
  950  (and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) fut-tag)))
  951(define fut-tag (list 'fut-tag))
  952(define (new-cst source decl val) (make-cst #f '() #t decl source val))
  953(define (new-ref source decl var)
  954  (let ((node (make-ref #f '() #t decl source var)))
  955    (var-refs-set! var (set-adjoin (var-refs var) node))
  956    node))
  957(define (new-ref-extended-bindings source name env)
  958  (new-ref source
  959           (add-extended-bindings (env-declarations env))
  960           (env-lookup-global-var env name)))
  961(define (new-set source decl var val)
  962  (let ((node (make-set #f (list val) #t decl source var)))
  963    (var-sets-set! var (set-adjoin (var-sets var) node))
  964    (node-parent-set! val node)
  965    node))
  966(define (set-val x)
  967  (if (set? x)
  968      (car (node-children x))
  969      (compiler-internal-error "set-val, 'set' node expected" x)))
  970(define (new-def source decl var val)
  971  (let ((node (make-def #f (list val) #t decl source var)))
  972    (var-sets-set! var (set-adjoin (var-sets var) node))
  973    (node-parent-set! val node)
  974    node))
  975(define (def-val x)
  976  (if (def? x)
  977      (car (node-children x))
  978      (compiler-internal-error "def-val, 'def' node expected" x)))
  979(define (new-tst source decl pre con alt)
  980  (let ((node (make-tst #f (list pre con alt) #t decl source)))
  981    (node-parent-set! pre node)
  982    (node-parent-set! con node)
  983    (node-parent-set! alt node)
  984    node))
  985(define (tst-pre x)
  986  (if (tst? x)
  987      (car (node-children x))
  988      (compiler-internal-error "tst-pre, 'tst' node expected" x)))
  989(define (tst-con x)
  990  (if (tst? x)
  991      (cadr (node-children x))
  992      (compiler-internal-error "tst-con, 'tst' node expected" x)))
  993(define (tst-alt x)
  994  (if (tst? x)
  995      (caddr (node-children x))
  996      (compiler-internal-error "tst-alt, 'tst' node expected" x)))
  997(define (new-conj source decl pre alt)
  998  (let ((node (make-conj #f (list pre alt) #t decl source)))
  999    (node-parent-set! pre node)
  1000    (node-parent-set! alt node)
 1001    node))
 1002(define (conj-pre x)
 1003  (if (conj? x)
 1004      (car (node-children x))
 1005      (compiler-internal-error "conj-pre, 'conj' node expected" x)))
 1006(define (conj-alt x)
 1007  (if (conj? x)
 1008      (cadr (node-children x))
 1009      (compiler-internal-error "conj-alt, 'conj' node expected" x)))
 1010(define (new-disj source decl pre alt)
 1011  (let ((node (make-disj #f (list pre alt) #t decl source)))
 1012    (node-parent-set! pre node)
 1013    (node-parent-set! alt node)
 1014    node))
 1015(define (disj-pre x)
 1016  (if (disj? x)
 1017      (car (node-children x))
 1018      (compiler-internal-error "disj-pre, 'disj' node expected" x)))
 1019(define (disj-alt x)
 1020  (if (disj? x)
 1021      (cadr (node-children x))
 1022      (compiler-internal-error "disj-alt, 'disj' node expected" x)))
 1023(define (new-prc source decl name min rest parms body)
 1024  (let ((node (make-prc #f (list body) #t decl source name min rest parms)))
 1025    (for-each (lambda (x) (var-bound-set! x node)) parms)
 1026    (node-parent-set! body node)
 1027    node))
 1028(define (prc-body x)
 1029  (if (prc? x)
 1030      (car (node-children x))
 1031      (compiler-internal-error "prc-body, 'proc' node expected" x)))
 1032(define (new-call source decl oper args)
 1033  (let ((node (make-app #f (cons oper args) #t decl source)))
 1034    (node-parent-set! oper node)
 1035    (for-each (lambda (x) (node-parent-set! x node)) args)
 1036    node))
 1037(define (new-call* source decl oper args)
 1038  (if *ptree-port*
 1039      (if (ref? oper)
 1040          (let ((var (ref-var oper)))
 1041            (if (global? var)
 1042                (let ((proc (standard-procedure
 1043                             (var-name var)
 1044                             (node-decl oper))))
 1045                  (if (and proc
 1046                           (not (nb-args-conforms?
 1047                                 (length args)
 1048                                 (standard-procedure-call-pattern proc))))
 1049                      (begin
 1050                        (display "*** WARNING -- \"" *ptree-port*)
 1051                        (display (var-name var) *ptree-port*)
 1052                        (display "\" is called with " *ptree-port*)
 1053                        (display (length args) *ptree-port*)
 1054                        (display " argument(s)." *ptree-port*)
 1055                        (newline *ptree-port*))))))))
 1056  (new-call source decl oper args))
 1057(define (app-oper x)
 1058  (if (app? x)
 1059      (car (node-children x))
 1060      (compiler-internal-error "app-oper, 'call' node expected" x)))
 1061(define (app-args x)
 1062  (if (app? x)
 1063      (cdr (node-children x))
 1064      (compiler-internal-error "app-args, 'call' node expected" x)))
 1065(define (oper-pos? node)
 1066  (let ((parent (node-parent node)))
 1067    (if parent (and (app? parent) (eq? (app-oper parent) node)) #f)))
 1068(define (new-fut source decl val)
 1069  (let ((node (make-fut #f (list val) #t decl source)))
 1070    (node-parent-set! val node)
 1071    node))
 1072(define (fut-val x)
 1073  (if (fut? x)
 1074      (car (node-children x))
 1075      (compiler-internal-error "fut-val, 'fut' node expected" x)))
 1076(define (new-disj-call source decl pre oper alt)
 1077  (new-call*
 1078   source
 1079   decl
 1080   (let* ((parms (new-temps source '(temp))) (temp (car parms)))
 1081     (new-prc source
 1082              decl
 1083              #f
 1084              1
 1085              #f
 1086              parms
 1087              (new-tst source
 1088                       decl
 1089                       (new-ref source decl temp)
 1090                       (new-call*
 1091                        source
 1092                        decl
 1093                        oper
 1094                        (list (new-ref source decl temp)))
 1095                       alt)))
 1096   (list pre)))
 1097(define (new-seq source decl before after)
 1098  (new-call*
 1099   source
 1100   decl
 1101   (new-prc source decl #f 1 #f (new-temps source '(temp)) after)
 1102   (list before)))
 1103(define (new-let ptree proc vars vals body)
 1104  (if (pair? vars)
 1105      (new-call
 1106       (node-source ptree)
 1107       (node-decl ptree)
 1108       (new-prc (node-source proc)
 1109                (node-decl proc)
 1110                (prc-name proc)
 1111                (length vars)
 1112                #f
 1113                (reverse vars)
 1114                body)
 1115       (reverse vals))
 1116      body))
 1117(define (new-temps source names)
 1118  (if (null? names)
 1119      '()
 1120      (cons (make-var (car names) #t (set-empty) (set-empty) source)
 1121            (new-temps source (cdr names)))))
 1122(define (new-variables vars)
 1123  (if (null? vars)
 1124      '()
 1125      (cons (make-var
 1126             (source-code (car vars))
 1127             #t
 1128             (set-empty)
 1129             (set-empty)
 1130             (car vars))
 1131            (new-variables (cdr vars)))))
 1132(define (set-prc-names! vars vals)
 1133  (let loop ((vars vars) (vals vals))
 1134    (if (not (null? vars))
 1135        (let ((var (car vars)) (val (car vals)))
 1136          (if (prc? val) (prc-name-set! val (symbol->string (var-name var))))
 1137          (loop (cdr vars) (cdr vals))))))
 1138(define (free-variables node)
 1139  (if (eq? (node-fv node) #t)
 1140      (let ((x (apply set-union (map free-variables (node-children node)))))
 1141        (node-fv-set!
 1142         node
 1143         (cond ((ref? node)
 1144                (if (global? (ref-var node)) x (set-adjoin x (ref-var node))))
 1145               ((set? node)
 1146                (if (global? (set-var node)) x (set-adjoin x (set-var node))))
 1147               ((prc? node) (set-difference x (list->set (prc-parms node))))
 1148               ((and (app? node) (prc? (app-oper node)))
 1149                (set-difference x (list->set (prc-parms (app-oper node)))))
 1150               (else x)))))
 1151  (node-fv node))
 1152(define (bound-variables node) (list->set (prc-parms node)))
 1153(define (not-mutable? var) (set-empty? (var-sets var)))
 1154(define (mutable? var) (not (not-mutable? var)))
 1155(define (bound? var) (var-bound var))
 1156(define (global? var) (not (bound? var)))
 1157(define (global-val var)
 1158  (and (global? var)
 1159       (let ((sets (set->list (var-sets var))))
 1160         (and (pair? sets)
 1161              (null? (cdr sets))
 1162              (def? (car sets))
 1163              (eq? (compilation-strategy (node-decl (car sets))) block-sym)
 1164              (def-val (car sets))))))
 1165(define **not-sym (string->canonical-symbol "##NOT"))
 1166(define **quasi-append-sym (string->canonical-symbol "##QUASI-APPEND"))
 1167(define **quasi-list-sym (string->canonical-symbol "##QUASI-LIST"))
 1168(define **quasi-cons-sym (string->canonical-symbol "##QUASI-CONS"))
 1169(define **quasi-list->vector-sym
 1170  (string->canonical-symbol "##QUASI-LIST->VECTOR"))
 1171(define **case-memv-sym (string->canonical-symbol "##CASE-MEMV"))
 1172(define **unassigned?-sym (string->canonical-symbol "##UNASSIGNED?"))
 1173(define **make-cell-sym (string->canonical-symbol "##MAKE-CELL"))
 1174(define **cell-ref-sym (string->canonical-symbol "##CELL-REF"))
 1175(define **cell-set!-sym (string->canonical-symbol "##CELL-SET!"))
 1176(define **make-placeholder-sym (string->canonical-symbol "##MAKE-PLACEHOLDER"))
 1177(define ieee-scheme-sym (string->canonical-symbol "IEEE-SCHEME"))
 1178(define r4rs-scheme-sym (string->canonical-symbol "R4RS-SCHEME"))
 1179(define multilisp-sym (string->canonical-symbol "MULTILISP"))
 1180(define lambda-lift-sym (string->canonical-symbol "LAMBDA-LIFT"))
 1181(define block-sym (string->canonical-symbol "BLOCK"))
 1182(define separate-sym (string->canonical-symbol "SEPARATE"))
 1183(define standard-bindings-sym (string->canonical-symbol "STANDARD-BINDINGS"))
 1184(define extended-bindings-sym (string->canonical-symbol "EXTENDED-BINDINGS"))
 1185(define safe-sym (string->canonical-symbol "SAFE"))
 1186(define interrupts-enabled-sym (string->canonical-symbol "INTERRUPTS-ENABLED"))
 1187(define-flag-decl ieee-scheme-sym 'dialect)
 1188(define-flag-decl r4rs-scheme-sym 'dialect)
 1189(define-flag-decl multilisp-sym 'dialect)
 1190(define-boolean-decl lambda-lift-sym)
 1191(define-flag-decl block-sym 'compilation-strategy)
 1192(define-flag-decl separate-sym 'compilation-strategy)
 1193(define-namable-boolean-decl standard-bindings-sym)
 1194(define-namable-boolean-decl extended-bindings-sym)
 1195(define-boolean-decl safe-sym)
 1196(define-boolean-decl interrupts-enabled-sym)
 1197(define (scheme-dialect decl)
 1198  (declaration-value 'dialect #f ieee-scheme-sym decl))
 1199(define (lambda-lift? decl) (declaration-value lambda-lift-sym #f #t decl))
 1200(define (compilation-strategy decl)
 1201  (declaration-value 'compilation-strategy #f separate-sym decl))
 1202(define (standard-binding? name decl)
 1203  (declaration-value standard-bindings-sym name #f decl))
 1204(define (extended-binding? name decl)
 1205  (declaration-value extended-bindings-sym name #f decl))
 1206(define (add-extended-bindings decl)
 1207  (add-decl (list extended-bindings-sym #t) decl))
 1208(define (intrs-enabled? decl)
 1209  (declaration-value interrupts-enabled-sym #f #t decl))
 1210(define (add-not-interrupts-enabled decl)
 1211  (add-decl (list interrupts-enabled-sym #f) decl))
 1212(define (safe? decl) (declaration-value safe-sym #f #f decl))
 1213(define (add-not-safe decl) (add-decl (list safe-sym #f) decl))
 1214(define (dialect-specific-keywords dialect)
 1215  (cond ((eq? dialect ieee-scheme-sym) ieee-scheme-specific-keywords)
 1216        ((eq? dialect r4rs-scheme-sym) r4rs-scheme-specific-keywords)
 1217        ((eq? dialect multilisp-sym) multilisp-specific-keywords)
 1218        (else
 1219         (compiler-internal-error
 1220          "dialect-specific-keywords, unknown dialect"
 1221          dialect))))
 1222(define (dialect-specific-procedures dialect)
 1223  (cond ((eq? dialect ieee-scheme-sym) ieee-scheme-specific-procedures)
 1224        ((eq? dialect r4rs-scheme-sym) r4rs-scheme-specific-procedures)
 1225        ((eq? dialect multilisp-sym) multilisp-specific-procedures)
 1226        (else
 1227         (compiler-internal-error
 1228          "dialect-specific-procedures, unknown dialect"
 1229          dialect))))
 1230(define (make-standard-procedure x)
 1231  (cons (string->canonical-symbol (car x)) (cdr x)))
 1232(define (standard-procedure name decl)
 1233  (or (assq name (dialect-specific-procedures (scheme-dialect decl)))
 1234      (assq name common-procedures)))
 1235(define (standard-procedure-call-pattern proc) (cdr proc))
 1236(define ieee-scheme-specific-keywords '())
 1237(define ieee-scheme-specific-procedures (map make-standard-procedure '()))
 1238(define r4rs-scheme-specific-keywords (list delay-sym))
 1239(define r4rs-scheme-specific-procedures
 1240  (map make-standard-procedure
 1241       '(("LIST-TAIL" 2)
 1242         ("-" . 1)
 1243         ("/" . 1)
 1244         ("STRING->LIST" 1)
 1245         ("LIST->STRING" 1)
 1246         ("STRING-COPY" 1)
 1247         ("STRING-FILL!" 2)
 1248         ("VECTOR->LIST" 1)
 1249         ("LIST->VECTOR" 1)
 1250         ("VECTOR-FILL!" 2)
 1251         ("FORCE" 1)
 1252         ("WITH-INPUT-FROM-FILE" 2)
 1253         ("WITH-OUTPUT-TO-FILE" 2)
 1254         ("CHAR-READY?" 0 1)
 1255         ("LOAD" 1)
 1256         ("TRANSCRIPT-ON" 1)
 1257         ("TRANSCRIPT-OFF" 0))))
 1258(define multilisp-specific-keywords (list delay-sym future-sym))
 1259(define multilisp-specific-procedures
 1260  (map make-standard-procedure '(("FORCE" 1) ("TOUCH" 1))))
 1261(define common-keywords
 1262  (list quote-sym
 1263        quasiquote-sym
 1264        unquote-sym
 1265        unquote-splicing-sym
 1266        lambda-sym
 1267        if-sym
 1268        set!-sym
 1269        cond-sym
 1270        =>-sym
 1271        else-sym
 1272        and-sym
 1273        or-sym
 1274        case-sym
 1275        let-sym
 1276        let*-sym
 1277        letrec-sym
 1278        begin-sym
 1279        do-sym
 1280        define-sym
 1281        **define-macro-sym
 1282        **declare-sym
 1283        **include-sym))
 1284(define common-procedures
 1285  (map make-standard-procedure
 1286       '(("NOT" 1)
 1287         ("BOOLEAN?" 1)
 1288         ("EQV?" 2)
 1289         ("EQ?" 2)
 1290         ("EQUAL?" 2)
 1291         ("PAIR?" 1)
 1292         ("CONS" 2)
 1293         ("CAR" 1)
 1294         ("CDR" 1)
 1295         ("SET-CAR!" 2)
 1296         ("SET-CDR!" 2)
 1297         ("CAAR" 1)
 1298         ("CADR" 1)
 1299         ("CDAR" 1)
 1300         ("CDDR" 1)
 1301         ("CAAAR" 1)
 1302         ("CAADR" 1)
 1303         ("CADAR" 1)
 1304         ("CADDR" 1)
 1305         ("CDAAR" 1)
 1306         ("CDADR" 1)
 1307         ("CDDAR" 1)
 1308         ("CDDDR" 1)
 1309         ("CAAAAR" 1)
 1310         ("CAAADR" 1)
 1311         ("CAADAR" 1)
 1312         ("CAADDR" 1)
 1313         ("CADAAR" 1)
 1314         ("CADADR" 1)
 1315         ("CADDAR" 1)
 1316         ("CADDDR" 1)
 1317         ("CDAAAR" 1)
 1318         ("CDAADR" 1)
 1319         ("CDADAR" 1)
 1320         ("CDADDR" 1)
 1321         ("CDDAAR" 1)
 1322         ("CDDADR" 1)
 1323         ("CDDDAR" 1)
 1324         ("CDDDDR" 1)
 1325         ("NULL?" 1)
 1326         ("LIST?" 1)
 1327         ("LIST" . 0)
 1328         ("LENGTH" 1)
 1329         ("APPEND" . 0)
 1330         ("REVERSE" 1)
 1331         ("LIST-REF" 2)
 1332         ("MEMQ" 2)
 1333         ("MEMV" 2)
 1334         ("MEMBER" 2)
 1335         ("ASSQ" 2)
 1336         ("ASSV" 2)
 1337         ("ASSOC" 2)
 1338         ("SYMBOL?" 1)
 1339         ("SYMBOL->STRING" 1)
 1340         ("STRING->SYMBOL" 1)
 1341         ("NUMBER?" 1)
 1342         ("COMPLEX?" 1)
 1343         ("REAL?" 1)
 1344         ("RATIONAL?" 1)
 1345         ("INTEGER?" 1)
 1346         ("EXACT?" 1)
 1347         ("INEXACT?" 1)
 1348         ("=" . 2)
 1349         ("<" . 2)
 1350         (">" . 2)
 1351         ("<=" . 2)
 1352         (">=" . 2)
 1353         ("ZERO?" 1)
 1354         ("POSITIVE?" 1)
 1355         ("NEGATIVE?" 1)
 1356         ("ODD?" 1)
 1357         ("EVEN?" 1)
 1358         ("MAX" . 1)
 1359         ("MIN" . 1)
 1360         ("+" . 0)
 1361         ("*" . 0)
 1362         ("-" 1 2)
 1363         ("/" 1 2)
 1364         ("ABS" 1)
 1365         ("QUOTIENT" 2)
 1366         ("REMAINDER" 2)
 1367         ("MODULO" 2)
 1368         ("GCD" . 0)
 1369         ("LCM" . 0)
 1370         ("NUMERATOR" 1)
 1371         ("DENOMINATOR" 1)
 1372         ("FLOOR" 1)
 1373         ("CEILING" 1)
 1374         ("TRUNCATE" 1)
 1375         ("ROUND" 1)
 1376         ("RATIONALIZE" 2)
 1377         ("EXP" 1)
 1378         ("LOG" 1)
 1379         ("SIN" 1)
 1380         ("COS" 1)
 1381         ("TAN" 1)
 1382         ("ASIN" 1)
 1383         ("ACOS" 1)
 1384         ("ATAN" 1 2)
 1385         ("SQRT" 1)
 1386         ("EXPT" 2)
 1387         ("MAKE-RECTANGULAR" 2)
 1388         ("MAKE-POLAR" 2)
 1389         ("REAL-PART" 1)
 1390         ("IMAG-PART" 1)
 1391         ("MAGNITUDE" 1)
 1392         ("ANGLE" 1)
 1393         ("EXACT->INEXACT" 1)
 1394         ("INEXACT->EXACT" 1)
 1395         ("NUMBER->STRING" 1 2)
 1396         ("STRING->NUMBER" 1 2)
 1397         ("CHAR?" 1)
 1398         ("CHAR=?" 2)
 1399         ("CHAR<?" 2)
 1400         ("CHAR>?" 2)
 1401         ("CHAR<=?" 2)
 1402         ("CHAR>=?" 2)
 1403         ("CHAR-CI=?" 2)
 1404         ("CHAR-CI<?" 2)
 1405         ("CHAR-CI>?" 2)
 1406         ("CHAR-CI<=?" 2)
 1407         ("CHAR-CI>=?" 2)
 1408         ("CHAR-ALPHABETIC?" 1)
 1409         ("CHAR-NUMERIC?" 1)
 1410         ("CHAR-WHITESPACE?" 1)
 1411         ("CHAR-UPPER-CASE?" 1)
 1412         ("CHAR-LOWER-CASE?" 1)
 1413         ("CHAR->INTEGER" 1)
 1414         ("INTEGER->CHAR" 1)
 1415         ("CHAR-UPCASE" 1)
 1416         ("CHAR-DOWNCASE" 1)
 1417         ("STRING?" 1)
 1418         ("MAKE-STRING" 1 2)
 1419         ("STRING" . 0)
 1420         ("STRING-LENGTH" 1)
 1421         ("STRING-REF" 2)
 1422         ("STRING-SET!" 3)
 1423         ("STRING=?" 2)
 1424         ("STRING<?" 2)
 1425         ("STRING>?" 2)
 1426         ("STRING<=?" 2)
 1427         ("STRING>=?" 2)
 1428         ("STRING-CI=?" 2)
 1429         ("STRING-CI<?" 2)
 1430         ("STRING-CI>?" 2)
 1431         ("STRING-CI<=?" 2)
 1432         ("STRING-CI>=?" 2)
 1433         ("SUBSTRING" 3)
 1434         ("STRING-APPEND" . 0)
 1435         ("VECTOR?" 1)
 1436         ("MAKE-VECTOR" 1 2)
 1437         ("VECTOR" . 0)
 1438         ("VECTOR-LENGTH" 1)
 1439         ("VECTOR-REF" 2)
 1440         ("VECTOR-SET!" 3)
 1441         ("PROCEDURE?" 1)
 1442         ("APPLY" . 2)
 1443         ("MAP" . 2)
 1444         ("FOR-EACH" . 2)
 1445         ("CALL-WITH-CURRENT-CONTINUATION" 1)
 1446         ("CALL-WITH-INPUT-FILE" 2)
 1447         ("CALL-WITH-OUTPUT-FILE" 2)
 1448         ("INPUT-PORT?" 1)
 1449         ("OUTPUT-PORT?" 1)
 1450         ("CURRENT-INPUT-PORT" 0)
 1451         ("CURRENT-OUTPUT-PORT" 0)
 1452         ("OPEN-INPUT-FILE" 1)
 1453         ("OPEN-OUTPUT-FILE" 1)
 1454         ("CLOSE-INPUT-PORT" 1)
 1455         ("CLOSE-OUTPUT-PORT" 1)
 1456         ("EOF-OBJECT?" 1)
 1457         ("READ" 0 1)
 1458         ("READ-CHAR" 0 1)
 1459         ("PEEK-CHAR" 0 1)
 1460         ("WRITE" 1 2)
 1461         ("DISPLAY" 1 2)
 1462         ("NEWLINE" 0 1)
 1463         ("WRITE-CHAR" 1 2))))
 1464(define (parse-program program env module-name proc)
 1465  (define (parse-prog program env lst proc)
 1466    (if (null? program)
 1467        (proc (reverse lst) env)
 1468        (let ((source (car program)))
 1469          (cond ((macro-expr? source env)
 1470                 (parse-prog
 1471                  (cons (macro-expand source env) (cdr program))
 1472                  env
 1473                  lst
 1474                  proc))
 1475                ((begin-defs-expr? source)
 1476                 (parse-prog
 1477                  (append (begin-defs-body source) (cdr program))
 1478                  env
 1479                  lst
 1480                  proc))
 1481                ((include-expr? source)
 1482                 (if *ptree-port* (display "  " *ptree-port*))
 1483                 (let ((x (file->sources*
 1484                           (include-filename source)
 1485                           *ptree-port*
 1486                           (source-locat source))))
 1487                   (if *ptree-port* (newline *ptree-port*))
 1488                   (parse-prog (append x (cdr program)) env lst proc)))
 1489                ((define-macro-expr? source env)
 1490                 (if *ptree-port*
 1491                     (begin
 1492                       (display "  \"macro\"" *ptree-port*)
 1493                       (newline *ptree-port*)))
 1494                 (parse-prog (cdr program) (add-macro source env) lst proc))
 1495                ((declare-expr? source)
 1496                 (if *ptree-port*
 1497                     (begin
 1498                       (display "  \"decl\"" *ptree-port*)
 1499                       (newline *ptree-port*)))
 1500                 (parse-prog
 1501                  (cdr program)
 1502                  (add-declarations source env)
 1503                  lst
 1504                  proc))
 1505                ((define-expr? source env)
 1506                 (let* ((var** (definition-variable source))
 1507                        (var* (source-code var**))
 1508                        (var (env-lookup-var env var* var**)))
 1509                   (if *ptree-port*
 1510                       (begin
 1511                         (display "  " *ptree-port*)
 1512                         (display (var-name var) *ptree-port*)
 1513                         (newline *ptree-port*)))
 1514                   (let ((node (pt (definition-value source) env 'true)))
 1515                     (set-prc-names! (list var) (list node))
 1516                     (parse-prog
 1517                      (cdr program)
 1518                      env
 1519                      (cons (cons (new-def source
 1520                                           (env-declarations env)
 1521                                           var
 1522                                           node)
 1523                                  env)
 1524                            lst)
 1525                      proc))))
 1526                ((c-declaration-expr? source)
 1527                 (if *ptree-port*
 1528                     (begin
 1529                       (display "  \"c-decl\"" *ptree-port*)
 1530                       (newline *ptree-port*)))
 1531                 (add-c-declaration (source-code (cadr (source-code source))))
 1532                 (parse-prog (cdr program) env lst proc))
 1533                ((c-init-expr? source)
 1534                 (if *ptree-port*
 1535                     (begin
 1536                       (display "  \"c-init\"" *ptree-port*)
 1537                       (newline *ptree-port*)))
 1538                 (add-c-init (source-code (cadr (source-code source))))
 1539                 (parse-prog (cdr program) env lst proc))
 1540                (else
 1541                 (if *ptree-port*
 1542                     (begin
 1543                       (display "  \"expr\"" *ptree-port*)
 1544                       (newline *ptree-port*)))
 1545                 (parse-prog
 1546                  (cdr program)
 1547                  env
 1548                  (cons (cons (pt source env 'true) env) lst)
 1549                  proc))))))
 1550  (if *ptree-port*
 1551      (begin (display "Parsing:" *ptree-port*) (newline *ptree-port*)))
 1552  (c-interface-begin module-name)
 1553  (parse-prog
 1554   program
 1555   env
 1556   '()
 1557   (lambda (lst env)
 1558     (if *ptree-port* (newline *ptree-port*))
 1559     (proc lst env (c-interface-end)))))
 1560(define (c-interface-begin module-name)
 1561  (set! c-interface-module-name module-name)
 1562  (set! c-interface-proc-count 0)
 1563  (set! c-interface-decls '())
 1564  (set! c-interface-procs '())
 1565  (set! c-interface-inits '())
 1566  #f)
 1567(define (c-interface-end)
 1568  (let ((i (make-c-intf
 1569            (reverse c-interface-decls)
 1570            (reverse c-interface-procs)
 1571            (reverse c-interface-inits))))
 1572    (set! c-interface-module-name #f)
 1573    (set! c-interface-proc-count #f)
 1574    (set! c-interface-decls #f)
 1575    (set! c-interface-procs #f)
 1576    (set! c-interface-inits #f)
 1577    i))
 1578(define c-interface-module-name #f)
 1579(define c-interface-proc-count #f)
 1580(define c-interface-decls #f)
 1581(define c-interface-procs #f)
 1582(define c-interface-inits #f)
 1583(define (make-c-intf decls procs inits) (vector decls procs inits))
 1584(define (c-intf-decls c-intf) (vector-ref c-intf 0))
 1585(define (c-intf-decls-set! c-intf x) (vector-set! c-intf 0 x))
 1586(define (c-intf-procs c-intf) (vector-ref c-intf 1))
 1587(define (c-intf-procs-set! c-intf x) (vector-set! c-intf 1 x))
 1588(define (c-intf-inits c-intf) (vector-ref c-intf 2))
 1589(define (c-intf-inits-set! c-intf x) (vector-set! c-intf 2 x))
 1590(define (c-declaration-expr? source)
 1591  (and (mymatch **c-declaration-sym 1 source)
 1592       (let ((code (source-code source)))
 1593         (or (string? (source-code (cadr code)))
 1594             (pt-syntax-error
 1595              source
 1596              "Argument to '##c-declaration' must be a string")))))
 1597(define (c-init-expr? source)
 1598  (and (mymatch **c-init-sym 1 source)
 1599       (let ((code (source-code source)))
 1600         (or (string? (source-code (cadr code)))
 1601             (pt-syntax-error
 1602              source
 1603              "Argument to '##c-init' must be a string")))))
 1604(define (c-procedure-expr? source)
 1605  (and (mymatch **c-procedure-sym 3 source)
 1606       (let ((code (source-code source)))
 1607         (if (not (string? (source-code (cadddr code))))
 1608             (pt-syntax-error
 1609              source
 1610              "Last argument to '##c-procedure' must be a string")
 1611             (check-arg-and-result-types source (cadr code) (caddr code))))))
 1612(define scheme-to-c-notation
 1613  (list (list void-sym "VOID" "void")
 1614        (list char-sym "CHAR" "char")
 1615        (list signed-char-sym "SCHAR" "signed char")
 1616        (list unsigned-char-sym "UCHAR" "unsigned char")
 1617        (list short-sym "SHORT" "short")
 1618        (list unsigned-short-sym "USHORT" "unsigned short")
 1619        (list int-sym "INT" "int")
 1620        (list unsigned-int-sym "UINT" "unsigned int")
 1621        (list long-sym "LONG" "long")
 1622        (list unsigned-long-sym "ULONG" "unsigned long")
 1623        (list float-sym "FLOAT" "float")
 1624        (list double-sym "DOUBLE" "double")
 1625        (list pointer-sym "POINTER" "void*")
 1626        (list boolean-sym "BOOLEAN" "int")
 1627        (list string-sym "STRING" "char*")
 1628        (list scheme-object-sym "SCMOBJ" "long")))
 1629(define (convert-type typ) (if (assq typ scheme-to-c-notation) typ #f))
 1630(define (check-arg-and-result-types source arg-typs-source res-typ-source)
 1631  (let ((arg-typs (source-code arg-typs-source))
 1632        (res-typ (source-code res-typ-source)))
 1633    (let ((res-type (convert-type res-typ)))
 1634      (if (not res-type)
 1635          (pt-syntax-error res-typ-source "Invalid result type")
 1636          (if (not (proper-length arg-typs))
 1637              (pt-syntax-error
 1638               arg-typs-source
 1639               "Ill-terminated argument type list")
 1640              (let loop ((lst arg-typs))
 1641                (if (pair? lst)
 1642                    (let* ((arg-typ (source-code (car lst)))
 1643                           (arg-type (convert-type arg-typ)))
 1644                      (if (or (not arg-type) (eq? arg-type void-sym))
 1645                          (pt-syntax-error (car lst) "Invalid argument type")
 1646                          (loop (cdr lst))))
 1647                    #t)))))))
 1648(define (add-c-declaration declaration-string)
 1649  (set! c-interface-decls (cons declaration-string c-interface-decls))
 1650  #f)
 1651(define (add-c-init initialization-code-string)
 1652  (set! c-interface-inits (cons initialization-code-string c-interface-inits))
 1653  #f)
 1654(define (add-c-proc scheme-name c-name arity def)
 1655  (set! c-interface-procs
 1656        (cons (vector scheme-name c-name arity def) c-interface-procs))
 1657  #f)
 1658(define (pt-c-procedure source env use)
 1659  (let* ((code (source-code source))
 1660         (name (build-c-procedure
 1661                (map source-code (source-code (cadr code)))
 1662                (source-code (caddr code))
 1663                (source-code (cadddr code))))
 1664         (decl (env-declarations env)))
 1665    (new-ref source decl (env-lookup-global-var env (string->symbol name)))))
 1666(define (build-c-procedure argument-types result-type proc-name-or-code)
 1667  (define proc-name?
 1668    (let loop ((i (- (string-length proc-name-or-code) 1)))
 1669      (if (>= i 0)
 1670          (let ((c (string-ref proc-name-or-code i)))
 1671            (if (or (char-alphabetic? c) (char=? c #\_)) (loop (- i 1)) #f))
 1672          #t)))
 1673  (define nl (string #\newline))
 1674  (define undefined-value "UND")
 1675  (define scheme-arg-prefix "ARG")
 1676  (define scheme-result-name "RESULT")
 1677  (define c-arg-prefix "arg")
 1678  (define c-result-name "result")
 1679  (define scheme-to-c-prefix "SCMOBJ_TO_")
 1680  (define c-to-scheme-suffix "_TO_SCMOBJ")
 1681  (define (c-type-name typ) (cadr (assq typ scheme-to-c-notation)))
 1682  (define (c-type-decl typ) (caddr (assq typ scheme-to-c-notation)))
 1683  (define (listify strings)
 1684    (if (null? strings)
 1685        ""
 1686        (string-append
 1687         (car strings)
 1688         (apply string-append
 1689                (map (lambda (s) (string-append "," s)) (cdr strings))))))
 1690  (define (scheme-arg-var t)
 1691    (string-append c-id-prefix scheme-arg-prefix (number->string (cdr t))))
 1692  (define (c-arg-var t)
 1693    (string-append c-id-prefix c-arg-prefix (number->string (cdr t))))
 1694  (define (make-c-procedure arg-types res-type)
 1695    (define (make-arg-decl)
 1696      (apply string-append
 1697             (map (lambda (t)
 1698                    (string-append
 1699                     (c-type-decl (car t))
 1700                     " "
 1701                     (c-arg-var t)
 1702                     ";"
 1703                     nl))
 1704                  arg-types)))
 1705    (define (make-conversions)
 1706      (if (not (null? arg-types))
 1707          (let loop ((lst arg-types) (str (string-append "if (" nl)))
 1708            (if (null? lst)
 1709                (string-append str "   )" nl)
 1710                (let ((t (car lst)) (rest (cdr lst)))
 1711                  (loop rest
 1712                        (string-append
 1713                         str
 1714                         "    "
 1715                         c-id-prefix
 1716                         scheme-to-c-prefix
 1717                         (c-type-name (car t))
 1718                         "("
 1719                         (scheme-arg-var t)
 1720                         ","
 1721                         (c-arg-var t)
 1722                         ")"
 1723                         (if (null? rest) "" " &&")
 1724                         nl)))))
 1725          ""))
 1726    (define (make-body)
 1727      (if proc-name?
 1728          (let* ((param-list (listify (map c-arg-var arg-types)))
 1729                 (call (string-append proc-name-or-code "(" param-list ")")))
 1730            (if (eq? res-type void-sym)
 1731                (string-append
 1732                 "{"
 1733                 nl
 1734                 call
 1735                 ";"
 1736                 nl
 1737                 c-id-prefix
 1738                 scheme-result-name
 1739                 " = "
 1740                 c-id-prefix
 1741                 undefined-value
 1742                 ";"
 1743                 nl
 1744                 "}"
 1745                 nl)
 1746                (string-append
 1747                 c-id-prefix
 1748                 (c-type-name res-type)
 1749                 c-to-scheme-suffix
 1750                 "("
 1751                 call
 1752                 ","
 1753                 c-id-prefix
 1754                 scheme-result-name
 1755                 ");"
 1756                 nl)))
 1757          (if (eq? res-type void-sym)
 1758              (string-append
 1759               "{"
 1760               nl
 1761               proc-name-or-code
 1762               nl
 1763               c-id-prefix
 1764               scheme-result-name
 1765               " = "
 1766               c-id-prefix
 1767               undefined-value
 1768               ";"
 1769               nl
 1770               "}"
 1771               nl)
 1772              (string-append
 1773               "{"
 1774               nl
 1775               proc-name-or-code
 1776               nl
 1777               c-id-prefix
 1778               (c-type-name res-type)
 1779               c-to-scheme-suffix
 1780               "("
 1781               c-id-prefix
 1782               c-result-name
 1783               ","
 1784               c-id-prefix
 1785               scheme-result-name
 1786               ");"
 1787               nl
 1788               "}"
 1789               nl))))
 1790    (let* ((index (number->string c-interface-proc-count))
 1791           (scheme-name (string-append "#!" c-interface-module-name "#" index))
 1792           (c-name (string-append c-id-prefix (scheme-id->c-id scheme-name)))
 1793           (arity (length argument-types))
 1794           (def (string-append
 1795                 (if (or proc-name? (eq? res-type void-sym))
 1796                     ""
 1797                     (string-append
 1798                      (c-type-decl res-type)
 1799                      " "
 1800                      c-id-prefix
 1801                      c-result-name
 1802                      ";"
 1803                      nl))
 1804                 (make-arg-decl)
 1805                 (make-conversions)
 1806                 (make-body))))
 1807      (set! c-interface-proc-count (+ c-interface-proc-count 1))
 1808      (add-c-proc scheme-name c-name arity def)
 1809      scheme-name))
 1810  (let loop ((i 1) (lst1 argument-types) (lst2 '()))
 1811    (if (pair? lst1)
 1812        (loop (+ i 1) (cdr lst1) (cons (cons (car lst1) i) lst2))
 1813        (make-c-procedure (reverse lst2) result-type))))
 1814(define (scheme-id->c-id s)
 1815  (define (hex->char i) (string-ref "0123456789abcdef" i))
 1816  (let loop ((i (- (string-length s) 1)) (l '()))
 1817    (if (>= i 0)
 1818        (let ((c (string-ref s i)))
 1819          (cond ((or (char-alphabetic? c) (char-numeric? c))
 1820                 (loop (- i 1) (cons c l)))
 1821                ((char=? c #\_) (loop (- i 1) (cons c (cons c l))))
 1822                (else
 1823                 (let ((n (character-encoding c)))
 1824                   (loop (- i 1)
 1825                         (cons #\_
 1826                               (cons (hex->char (quotient n 16))
 1827                                     (cons (hex->char (modulo n 16)) l))))))))
 1828        (lst->string l))))
 1829(define (pt-syntax-error source msg . args)
 1830  (apply compiler-user-error
 1831         (cons (source-locat source)
 1832               (cons (string-append "Syntax error -- " msg) args))))
 1833(define (pt source env use)
 1834  (cond ((macro-expr? source env) (pt (macro-expand source env) env use))
 1835        ((self-eval-expr? source) (pt-self-eval source env use))
 1836        ((quote-expr? source) (pt-quote source env use))
 1837        ((quasiquote-expr? source) (pt-quasiquote source env use))
 1838        ((unquote-expr? source)
 1839         (pt-syntax-error source "Ill-placed 'unquote'"))
 1840        ((unquote-splicing-expr? source)
 1841         (pt-syntax-error source "Ill-placed 'unquote-splicing'"))
 1842        ((var-expr? source env) (pt-var source env use))
 1843        ((set!-expr? source env) (pt-set! source env use))
 1844        ((lambda-expr? source env) (pt-lambda source env use))
 1845        ((if-expr? source) (pt-if source env use))
 1846        ((cond-expr? source) (pt-cond source env use))
 1847        ((and-expr? source) (pt-and source env use))
 1848        ((or-expr? source) (pt-or source env use))
 1849        ((case-expr? source) (pt-case source env use))
 1850        ((let-expr? source env) (pt-let source env use))
 1851        ((let*-expr? source env) (pt-let* source env use))
 1852        ((letrec-expr? source env) (pt-letrec source env use))
 1853        ((begin-expr? source) (pt-begin source env use))
 1854        ((do-expr? source env) (pt-do source env use))
 1855        ((define-expr? source env)
 1856         (pt-syntax-error source "Ill-placed 'define'"))
 1857        ((delay-expr? source env) (pt-delay source env use))
 1858        ((future-expr? source env) (pt-future source env use))
 1859        ((define-macro-expr? source env)
 1860         (pt-syntax-error source "Ill-placed '##define-macro'"))
 1861        ((begin-defs-expr? source)
 1862         (pt-syntax-error source "Ill-placed 'begin' style definitions"))
 1863        ((declare-expr? source)
 1864         (pt-syntax-error source "Ill-placed '##declare'"))
 1865        ((c-declaration-expr? source)
 1866         (pt-syntax-error source "Ill-placed '##c-declaration'"))
 1867        ((c-init-expr? source)
 1868         (pt-syntax-error source "Ill-placed '##c-init'"))
 1869        ((c-procedure-expr? source) (pt-c-procedure source env use))
 1870        ((combination-expr? source) (pt-combination source env use))
 1871        (else (compiler-internal-error "pt, unknown expression type" source))))
 1872(define (macro-expand source env)
 1873  (let ((code (source-code source)))
 1874    (expression->source
 1875     (apply (cdr (env-lookup-macro env (source-code (car code))))
 1876            (cdr (source->expression source)))
 1877     source)))
 1878(define (pt-self-eval source env use)
 1879  (let ((val (source->expression source)))
 1880    (if (eq? use 'none)
 1881        (new-cst source (env-declarations env) undef-object)
 1882        (new-cst source (env-declarations env) val))))
 1883(define (pt-quote source env use)
 1884  (let ((code (source-code source)))
 1885    (if (eq? use 'none)
 1886        (new-cst source (env-declarations env) undef-object)
 1887        (new-cst source
 1888                 (env-declarations env)
 1889                 (source->expression (cadr code))))))
 1890(define (pt-quasiquote source env use)
 1891  (let ((code (source-code source))) (pt-quasiquotation (cadr code) 1 env)))
 1892(define (pt-quasiquotation form level env)
 1893  (cond ((= level 0) (pt form env 'true))
 1894        ((quasiquote-expr? form)
 1895         (pt-quasiquotation-list form (source-code form) (+ level 1) env))
 1896        ((unquote-expr? form)
 1897         (if (= level 1)
 1898             (pt (cadr (source-code form)) env 'true)
 1899             (pt-quasiquotation-list form (source-code form) (- level 1) env)))
 1900        ((unquote-splicing-expr? form)
 1901         (if (= level 1)
 1902             (pt-syntax-error form "Ill-placed 'unquote-splicing'")
 1903             (pt-quasiquotation-list form (source-code form) (- level 1) env)))
 1904        ((pair? (source-code form))
 1905         (pt-quasiquotation-list form (source-code form) level env))
 1906        ((vector? (source-code form))
 1907         (vector-form
 1908          form
 1909          (pt-quasiquotation-list
 1910           form
 1911           (vector->lst (source-code form))
 1912           level
 1913           env)
 1914          env))
 1915        (else
 1916         (new-cst form (env-declarations env) (source->expression form)))))
 1917(define (pt-quasiquotation-list form l level env)
 1918  (cond ((pair? l)
 1919         (if (and (unquote-splicing-expr? (car l)) (= level 1))
 1920             (let ((x (pt (cadr (source-code (car l))) env 'true)))
 1921               (if (null? (cdr l))
 1922                   x
 1923                   (append-form
 1924                    (car l)
 1925                    x
 1926                    (pt-quasiquotation-list form (cdr l) 1 env)
 1927                    env)))
 1928             (cons-form
 1929              form
 1930              (pt-quasiquotation (car l) level env)
 1931              (pt-quasiquotation-list form (cdr l) level env)
 1932              env)))
 1933        ((null? l) (new-cst form (env-declarations env) '()))
 1934        (else (pt-quasiquotation l level env))))
 1935(define (append-form source ptree1 ptree2 env)
 1936  (cond ((and (cst? ptree1) (cst? ptree2))
 1937         (new-cst source
 1938                  (env-declarations env)
 1939                  (append (cst-val ptree1) (cst-val ptree2))))
 1940        ((and (cst? ptree2) (null? (cst-val ptree2))) ptree1)
 1941        (else
 1942         (new-call*
 1943          source
 1944          (add-not-safe (env-declarations env))
 1945          (new-ref-extended-bindings source **quasi-append-sym env)
 1946          (list ptree1 ptree2)))))
 1947(define (cons-form source ptree1 ptree2 env)
 1948  (cond ((and (cst? ptree1) (cst? ptree2))
 1949         (new-cst source
 1950                  (env-declarations env)
 1951                  (cons (cst-val ptree1) (cst-val ptree2))))
 1952        ((and (cst? ptree2) (null? (cst-val ptree2)))
 1953         (new-call*
 1954          source
 1955          (add-not-safe (env-declarations env))
 1956          (new-ref-extended-bindings source **quasi-list-sym env)
 1957          (list ptree1)))
 1958        (else
 1959         (new-call*
 1960          source
 1961          (add-not-safe (env-declarations env))
 1962          (new-ref-extended-bindings source **quasi-cons-sym env)
 1963          (list ptree1 ptree2)))))
 1964(define (vector-form source ptree env)
 1965  (if (cst? ptree)
 1966      (new-cst source (env-declarations env) (lst->vector (cst-val ptree)))
 1967      (new-call*
 1968       source
 1969       (add-not-safe (env-declarations env))
 1970       (new-ref-extended-bindings source **quasi-list->vector-sym env)
 1971       (list ptree))))
 1972(define (pt-var source env use)
 1973  (if (eq? use 'none)
 1974      (new-cst source (env-declarations env) undef-object)
 1975      (new-ref source
 1976               (env-declarations env)
 1977               (env-lookup-var env (source-code source) source))))
 1978(define (pt-set! source env use)
 1979  (let ((code (source-code source)))
 1980    (new-set source
 1981             (env-declarations env)
 1982             (env-lookup-var env (source-code (cadr code)) (cadr code))
 1983             (pt (caddr code) env 'true))))
 1984(define (pt-lambda source env use)
 1985  (let ((code (source-code source)))
 1986    (define (new-params parms)
 1987      (cond ((pair? parms)
 1988             (let* ((parm* (car parms))
 1989                    (parm (source-code parm*))
 1990                    (p* (if (pair? parm) (car parm) parm*)))
 1991               (cons (make-var (source-code p*) #t (set-empty) (set-empty) p*)
 1992                     (new-params (cdr parms)))))
 1993            ((null? parms) '())
 1994            (else
 1995             (list (make-var
 1996                    (source-code parms)
 1997                    #t
 1998                    (set-empty)
 1999                    (set-empty)
 2000                    parms)))))
 2001    (define (min-params parms)
 2002      (let loop ((l parms) (n 0))
 2003        (if (pair? l)
 2004            (if (pair? (source-code (car l))) n (loop (cdr l) (+ n 1)))
 2005            n)))
 2006    (define (rest-param? parms)
 2007      (if (pair? parms) (rest-param? (cdr parms)) (not (null? parms))))
 2008    (define (optionals parms source body env)
 2009      (if (pair? parms)
 2010          (let* ((parm* (car parms)) (parm (source-code parm*)))
 2011            (if (and (pair? parm) (length? parm 2))
 2012                (let* ((var (car parm))
 2013                       (vars (new-variables (list var)))
 2014                       (decl (env-declarations env)))
 2015                  (new-call*
 2016                   parm*
 2017                   decl
 2018                   (new-prc parm*
 2019                            decl
 2020                            #f
 2021                            1
 2022                            #f
 2023                            vars
 2024                            (optionals
 2025                             (cdr parms)
 2026                             source
 2027                             body
 2028                             (env-frame env vars)))
 2029                   (list (new-tst parm*
 2030                                  decl
 2031                                  (new-call*
 2032                                   parm*
 2033                                   decl
 2034                                   (new-ref-extended-bindings
 2035                                    parm*
 2036                                    **unassigned?-sym
 2037                                    env)
 2038                                   (list (new-ref parm*
 2039                                                  decl
 2040                                                  (env-lookup-var
 2041                                                   env
 2042                                                   (source-code var)
 2043                                                   var))))
 2044                                  (pt (cadr parm) env 'true)
 2045                                  (new-ref parm*
 2046                                           decl
 2047                                           (env-lookup-var
 2048                                            env
 2049                                            (source-code var)
 2050                                            var))))))
 2051                (optionals (cdr parms) source body env)))
 2052          (pt-body source body env 'true)))
 2053    (if (eq? use 'none)
 2054        (new-cst source (env-declarations env) undef-object)
 2055        (let* ((parms (source->parms (cadr code))) (frame (new-params parms)))
 2056          (new-prc source
 2057                   (env-declarations env)
 2058                   #f
 2059                   (min-params parms)
 2060                   (rest-param? parms)
 2061                   frame
 2062                   (optionals
 2063                    parms
 2064                    source
 2065                    (cddr code)
 2066                    (env-frame env frame)))))))
 2067(define (source->parms source)
 2068  (let ((x (source-code source))) (if (or (pair? x) (null? x)) x source)))
 2069(define (pt-body source body env use)
 2070  (define (letrec-defines vars vals envs body env)
 2071    (cond ((null? body)
 2072           (pt-syntax-error
 2073            source
 2074            "Body must contain at least one evaluable expression"))
 2075          ((macro-expr? (car body) env)
 2076           (letrec-defines
 2077            vars
 2078            vals
 2079            envs
 2080            (cons (macro-expand (car body) env) (cdr body))
 2081            env))
 2082          ((begin-defs-expr? (car body))
 2083           (letrec-defines
 2084            vars
 2085            vals
 2086            envs
 2087            (append (begin-defs-body (car body)) (cdr body))
 2088            env))
 2089          ((include-expr? (car body))
 2090           (if *ptree-port* (display "  " *ptree-port*))
 2091           (let ((x (file->sources*
 2092                     (include-filename (car body))
 2093                     *ptree-port*
 2094                     (source-locat (car body)))))
 2095             (if *ptree-port* (newline *ptree-port*))
 2096             (letrec-defines vars vals envs (append x (cdr body)) env)))
 2097          ((define-expr? (car body) env)
 2098           (let* ((var** (definition-variable (car body)))
 2099                  (var* (source-code var**))
 2100                  (var (env-define-var env var* var**)))
 2101             (letrec-defines
 2102              (cons var vars)
 2103              (cons (definition-value (car body)) vals)
 2104              (cons env envs)
 2105              (cdr body)
 2106              env)))
 2107          ((declare-expr? (car body))
 2108           (letrec-defines
 2109            vars
 2110            vals
 2111            envs
 2112            (cdr body)
 2113            (add-declarations (car body) env)))
 2114          ((define-macro-expr? (car body) env)
 2115           (letrec-defines
 2116            vars
 2117            vals
 2118            envs
 2119            (cdr body)
 2120            (add-macro (car body) env)))
 2121          ((c-declaration-expr? (car body))
 2122           (add-c-declaration (source-code (cadr (source-code (car body)))))
 2123           (letrec-defines vars vals envs (cdr body) env))
 2124          ((c-init-expr? (car body))
 2125           (add-c-init (source-code (cadr (source-code (car body)))))
 2126           (letrec-defines vars vals envs (cdr body) env))
 2127          ((null? vars) (pt-sequence source body env use))
 2128          (else
 2129           (let ((vars* (reverse vars)))
 2130             (let loop ((vals* '()) (l1 vals) (l2 envs))
 2131               (if (not (null? l1))
 2132                   (loop (cons (pt (car l1) (car l2) 'true) vals*)
 2133                         (cdr l1)
 2134                         (cdr l2))
 2135                   (pt-recursive-let source vars* vals* body env use)))))))
 2136  (letrec-defines '() '() '() body (env-frame env '())))
 2137(define (pt-sequence source seq env use)
 2138  (if (length? seq 1)
 2139      (pt (car seq) env use)
 2140      (new-seq source
 2141               (env-declarations env)
 2142               (pt (car seq) env 'none)
 2143               (pt-sequence source (cdr seq) env use))))
 2144(define (pt-if source env use)
 2145  (let ((code (source-code source)))
 2146    (new-tst source
 2147             (env-declarations env)
 2148             (pt (cadr code) env 'pred)
 2149             (pt (caddr code) env use)
 2150             (if (length? code 3)
 2151                 (new-cst source (env-declarations env) undef-object)
 2152                 (pt (cadddr code) env use)))))
 2153(define (pt-cond source env use)
 2154  (define (pt-clauses clauses)
 2155    (if (length? clauses 0)
 2156        (new-cst source (env-declarations env) undef-object)
 2157        (let* ((clause* (car clauses)) (clause (source-code clause*)))
 2158          (cond ((eq? (source-code (car clause)) else-sym)
 2159                 (pt-sequence clause* (cdr clause) env use))
 2160                ((length? clause 1)
 2161                 (new-disj
 2162                  clause*
 2163                  (env-declarations env)
 2164                  (pt (car clause) env (if (eq? use 'true) 'true 'pred))
 2165                  (pt-clauses (cdr clauses))))
 2166                ((eq? (source-code (cadr clause)) =>-sym)
 2167                 (new-disj-call
 2168                  clause*
 2169                  (env-declarations env)
 2170                  (pt (car clause) env 'true)
 2171                  (pt (caddr clause) env 'true)
 2172                  (pt-clauses (cdr clauses))))
 2173                (else
 2174                 (new-tst clause*
 2175                          (env-declarations env)
 2176                          (pt (car clause) env 'pred)
 2177                          (pt-sequence clause* (cdr clause) env use)
 2178                          (pt-clauses (cdr clauses))))))))
 2179  (pt-clauses (cdr (source-code source))))
 2180(define (pt-and source env use)
 2181  (define (pt-exprs exprs)
 2182    (cond ((length? exprs 0) (new-cst source (env-declarations env) #t))
 2183          ((length? exprs 1) (pt (car exprs) env use))
 2184          (else
 2185           (new-conj
 2186            (car exprs)
 2187            (env-declarations env)
 2188            (pt (car exprs) env (if (eq? use 'true) 'true 'pred))
 2189            (pt-exprs (cdr exprs))))))
 2190  (pt-exprs (cdr (source-code source))))
 2191(define (pt-or source env use)
 2192  (define (pt-exprs exprs)
 2193    (cond ((length? exprs 0)
 2194           (new-cst source (env-declarations env) false-object))
 2195          ((length? exprs 1) (pt (car exprs) env use))
 2196          (else
 2197           (new-disj
 2198            (car exprs)
 2199            (env-declarations env)
 2200            (pt (car exprs) env (if (eq? use 'true) 'true 'pred))
 2201            (pt-exprs (cdr exprs))))))
 2202  (pt-exprs (cdr (source-code source))))
 2203(define (pt-case source env use)
 2204  (let ((code (source-code source)) (temp (new-temps source '(temp))))
 2205    (define (pt-clauses clauses)
 2206      (if (length? clauses 0)
 2207          (new-cst source (env-declarations env) undef-object)
 2208          (let* ((clause* (car clauses)) (clause (source-code clause*)))
 2209            (if (eq? (source-code (car clause)) else-sym)
 2210                (pt-sequence clause* (cdr clause) env use)
 2211                (new-tst clause*
 2212                         (env-declarations env)
 2213                         (new-call*
 2214                          clause*
 2215                          (add-not-safe (env-declarations env))
 2216                          (new-ref-extended-bindings
 2217                           clause*
 2218                           **case-memv-sym
 2219                           env)
 2220                          (list (new-ref clause*
 2221                                         (env-declarations env)
 2222                                         (car temp))
 2223                                (new-cst (car clause)
 2224                                         (env-declarations env)
 2225                                         (source->expression (car clause)))))
 2226                         (pt-sequence clause* (cdr clause) env use)
 2227                         (pt-clauses (cdr clauses)))))))
 2228    (new-call*
 2229     source
 2230     (env-declarations env)
 2231     (new-prc source
 2232              (env-declarations env)
 2233              #f
 2234              1
 2235              #f
 2236              temp
 2237              (pt-clauses (cddr code)))
 2238     (list (pt (cadr code) env 'true)))))
 2239(define (pt-let source env use)
 2240  (let ((code (source-code source)))
 2241    (if (bindable-var? (cadr code) env)
 2242        (let* ((self (new-variables (list (cadr code))))
 2243               (bindings (map source-code (source-code (caddr code))))
 2244               (vars (new-variables (map car bindings)))
 2245               (vals (map (lambda (x) (pt (cadr x) env 'true)) bindings))
 2246               (env (env-frame (env-frame env vars) self))
 2247               (self-proc
 2248                (list (new-prc source
 2249                               (env-declarations env)
 2250                               #f
 2251                               (length vars)
 2252                               #f
 2253                               vars
 2254                               (pt-body source (cdddr code) env use)))))
 2255          (set-prc-names! self self-proc)
 2256          (set-prc-names! vars vals)
 2257          (new-call*
 2258           source
 2259           (env-declarations env)
 2260           (new-prc source
 2261                    (env-declarations env)
 2262                    #f
 2263                    1
 2264                    #f
 2265                    self
 2266                    (new-call*
 2267                     source
 2268                     (env-declarations env)
 2269                     (new-ref source (env-declarations env) (car self))
 2270                     vals))
 2271           self-proc))
 2272        (if (null? (source-code (cadr code)))
 2273            (pt-body source (cddr code) env use)
 2274            (let* ((bindings (map source-code (source-code (cadr code))))
 2275                   (vars (new-variables (map car bindings)))
 2276                   (vals (map (lambda (x) (pt (cadr x) env 'true)) bindings))
 2277                   (env (env-frame env vars)))
 2278              (set-prc-names! vars vals)
 2279              (new-call*
 2280               source
 2281               (env-declarations env)
 2282               (new-prc source
 2283                        (env-declarations env)
 2284                        #f
 2285                        (length vars)
 2286                        #f
 2287                        vars
 2288                        (pt-body source (cddr code) env use))
 2289               vals))))))
 2290(define (pt-let* source env use)
 2291  (let ((code (source-code source)))
 2292    (define (pt-bindings bindings env use)
 2293      (if (null? bindings)
 2294          (pt-body source (cddr code) env use)
 2295          (let* ((binding* (car bindings))
 2296                 (binding (source-code binding*))
 2297                 (vars (new-variables (list (car binding))))
 2298                 (vals (list (pt (cadr binding) env 'true)))
 2299                 (env (env-frame env vars)))
 2300            (set-prc-names! vars vals)
 2301            (new-call*
 2302             binding*
 2303             (env-declarations env)
 2304             (new-prc binding*
 2305                      (env-declarations env)
 2306                      #f
 2307                      1
 2308                      #f
 2309                      vars
 2310                      (pt-bindings (cdr bindings) env use))
 2311             vals))))
 2312    (pt-bindings (source-code (cadr code)) env use)))
 2313(define (pt-letrec source env use)
 2314  (let* ((code (source-code source))
 2315         (bindings (map source-code (source-code (cadr code))))
 2316         (vars* (new-variables (map car bindings)))
 2317         (env* (env-frame env vars*)))
 2318    (pt-recursive-let
 2319     source
 2320     vars*
 2321     (map (lambda (x) (pt (cadr x) env* 'true)) bindings)
 2322     (cddr code)
 2323     env*
 2324     use)))
 2325(define (pt-recursive-let source vars vals body env use)
 2326  (define (dependency-graph vars vals)
 2327    (define (dgraph vars* vals*)
 2328      (if (null? vars*)
 2329          (set-empty)
 2330          (let ((var (car vars*)) (val (car vals*)))
 2331            (set-adjoin
 2332             (dgraph (cdr vars*) (cdr vals*))
 2333             (make-gnode
 2334              var
 2335              (set-intersection (list->set vars) (free-variables val)))))))
 2336    (dgraph vars vals))
 2337  (define (val-of var)
 2338    (list-ref vals (- (length vars) (length (memq var vars)))))
 2339  (define (bind-in-order order)
 2340    (if (null? order)
 2341        (pt-body source body env use)
 2342        (let* ((vars-set (car order)) (vars (set->list vars-set)))
 2343          (let loop1 ((l (reverse vars))
 2344                      (vars-b '())
 2345                      (vals-b '())
 2346                      (vars-a '()))
 2347            (if (not (null? l))
 2348                (let* ((var (car l)) (val (val-of var)))
 2349                  (if (or (prc? val)
 2350                          (set-empty?
 2351                           (set-intersection (free-variables val) vars-set)))
 2352                      (loop1 (cdr l)
 2353                             (cons var vars-b)
 2354                             (cons val vals-b)
 2355                             vars-a)
 2356                      (loop1 (cdr l) vars-b vals-b (cons var vars-a))))
 2357                (let* ((result1 (let loop2 ((l vars-a))
 2358                                  (if (not (null? l))
 2359                                      (let* ((var (car l)) (val (val-of var)))
 2360                                        (new-seq source
 2361                                                 (env-declarations env)
 2362                                                 (new-set source
 2363                                                          (env-declarations
 2364                                                           env)
 2365                                                          var
 2366                                                          val)
 2367                                                 (loop2 (cdr l))))
 2368                                      (bind-in-order (cdr order)))))
 2369                       (result2 (if (null? vars-b)
 2370                                    result1
 2371                                    (new-call*
 2372                                     source
 2373                                     (env-declarations env)
 2374                                     (new-prc source
 2375                                              (env-declarations env)
 2376                                              #f
 2377                                              (length vars-b)
 2378                                              #f
 2379                                              vars-b
 2380                                              result1)
 2381                                     vals-b)))
 2382                       (result3 (if (null? vars-a)
 2383                                    result2
 2384                                    (new-call*
 2385                                     source
 2386                                     (env-declarations env)
 2387                                     (new-prc source
 2388                                              (env-declarations env)
 2389                                              #f
 2390                                              (length vars-a)
 2391                                              #f
 2392                                              vars-a
 2393                                              result2)
 2394                                     (map (lambda (var)
 2395                                            (new-cst source
 2396                                                     (env-declarations env)
 2397                                                     undef-object))
 2398                                          vars-a)))))
 2399                  result3))))))
 2400  (set-prc-names! vars vals)
 2401  (bind-in-order
 2402   (topological-sort (transitive-closure (dependency-graph vars vals)))))
 2403(define (pt-begin source env use)
 2404  (pt-sequence source (cdr (source-code source)) env use))
 2405(define (pt-do source env use)
 2406  (let* ((code (source-code source))
 2407         (loop (new-temps source '(loop)))
 2408         (bindings (map source-code (source-code (cadr code))))
 2409         (vars (new-variables (map car bindings)))
 2410         (init (map (lambda (x) (pt (cadr x) env 'true)) bindings))
 2411         (env (env-frame env vars))
 2412         (step (map (lambda (x)
 2413                      (pt (if (length? x 2) (car x) (caddr x)) env 'true))
 2414                    bindings))
 2415         (exit (source-code (caddr code))))
 2416    (set-prc-names! vars init)
 2417    (new-call*
 2418     source
 2419     (env-declarations env)
 2420     (new-prc source
 2421              (env-declarations env)
 2422              #f
 2423              1
 2424              #f
 2425              loop
 2426              (new-call*
 2427               source
 2428               (env-declarations env)
 2429               (new-ref source (env-declarations env) (car loop))
 2430               init))
 2431     (list (new-prc source
 2432                    (env-declarations env)
 2433                    #f
 2434                    (length vars)
 2435                    #f
 2436                    vars
 2437                    (new-tst source
 2438                             (env-declarations env)
 2439                             (pt (car exit) env 'pred)
 2440                             (if (length? exit 1)
 2441                                 (new-cst (caddr code)
 2442                                          (env-declarations env)
 2443                                          undef-object)
 2444                                 (pt-sequence (caddr code) (cdr exit) env use))
 2445                             (if (length? code 3)
 2446                                 (new-call*
 2447                                  source
 2448                                  (env-declarations env)
 2449                                  (new-ref source
 2450                                           (env-declarations env)
 2451                                           (car loop))
 2452                                  step)
 2453                                 (new-seq source
 2454                                          (env-declarations env)
 2455                                          (pt-sequence
 2456                                           source
 2457                                           (cdddr code)
 2458                                           env
 2459                                           'none)
 2460                                          (new-call*
 2461                                           source
 2462                                           (env-declarations env)
 2463                                           (new-ref source
 2464                                                    (env-declarations env)
 2465                                                    (car loop))
 2466                                           step)))))))))
 2467(define (pt-combination source env use)
 2468  (let* ((code (source-code source))
 2469         (oper (pt (car code) env 'true))
 2470         (decl (node-decl oper)))
 2471    (new-call*
 2472     source
 2473     (env-declarations env)
 2474     oper
 2475     (map (lambda (x) (pt x env 'true)) (cdr code)))))
 2476(define (pt-delay source env use)
 2477  (let ((code (source-code source)))
 2478    (new-call*
 2479     source
 2480     (add-not-safe (env-declarations env))
 2481     (new-ref-extended-bindings source **make-placeholder-sym env)
 2482     (list (new-prc source
 2483                    (env-declarations env)
 2484                    #f
 2485                    0
 2486                    #f
 2487                    '()
 2488                    (pt (cadr code) env 'true))))))
 2489(define (pt-future source env use)
 2490  (let ((decl (env-declarations env)) (code (source-code source)))
 2491    (new-fut source decl (pt (cadr code) env 'true))))
 2492(define (self-eval-expr? source)
 2493  (let ((code (source-code source)))
 2494    (and (not (pair? code)) (not (symbol-object? code)))))
 2495(define (quote-expr? source) (mymatch quote-sym 1 source))
 2496(define (quasiquote-expr? source) (mymatch quasiquote-sym 1 source))
 2497(define (unquote-expr? source) (mymatch unquote-sym 1 source))
 2498(define (unquote-splicing-expr? source)
 2499  (mymatch unquote-splicing-sym 1 source))
 2500(define (var-expr? source env)
 2501  (let ((code (source-code source)))
 2502    (and (symbol-object? code)
 2503         (not-keyword source env code)
 2504         (not-macro source env code))))
 2505(define (not-macro source env name)
 2506  (if (env-lookup-macro env name)
 2507      (pt-syntax-error source "Macro name can't be used as a variable:" name)
 2508      #t))
 2509(define (bindable-var? source env)
 2510  (let ((code (source-code source)))
 2511    (and (symbol-object? code) (not-keyword source env code))))
 2512(define (not-keyword source env name)
 2513  (if (or (memq name common-keywords)
 2514          (memq name
 2515                (dialect-specific-keywords
 2516                 (scheme-dialect (env-declarations env)))))
 2517      (pt-syntax-error
 2518       source
 2519       "Predefined keyword can't be used as a variable:"
 2520       name)
 2521      #t))
 2522(define (set!-expr? source env)
 2523  (and (mymatch set!-sym 2 source)
 2524       (var-expr? (cadr (source-code source)) env)))
 2525(define (lambda-expr? source env)
 2526  (and (mymatch lambda-sym -2 source)
 2527       (proper-parms? (source->parms (cadr (source-code source))) env)))
 2528(define (if-expr? source)
 2529  (and (mymatch if-sym -2 source)
 2530       (or (<= (length (source-code source)) 4)
 2531           (pt-syntax-error source "Ill-formed special form" if-sym))))
 2532(define (cond-expr? source)
 2533  (and (mymatch cond-sym -1 source) (proper-clauses? source)))
 2534(define (and-expr? source) (mymatch and-sym 0 source))
 2535(define (or-expr? source) (mymatch or-sym 0 source))
 2536(define (case-expr? source)
 2537  (and (mymatch case-sym -2 source) (proper-case-clauses? source)))
 2538(define (let-expr? source env)
 2539  (and (mymatch let-sym -2 source)
 2540       (let ((code (source-code source)))
 2541         (if (bindable-var? (cadr code) env)
 2542             (and (proper-bindings? (caddr code) #t env)
 2543                  (or (> (length code) 3)
 2544                      (pt-syntax-error source "Ill-formed named 'let'")))
 2545             (proper-bindings? (cadr code) #t env)))))
 2546(define (let*-expr? source env)
 2547  (and (mymatch let*-sym -2 source)
 2548       (proper-bindings? (cadr (source-code source)) #f env)))
 2549(define (letrec-expr? source env)
 2550  (and (mymatch letrec-sym -2 source)
 2551       (proper-bindings? (cadr (source-code source)) #t env)))
 2552(define (begin-expr? source) (mymatch begin-sym -1 source))
 2553(define (do-expr? source env)
 2554  (and (mymatch do-sym -2 source)
 2555       (proper-do-bindings? source env)
 2556       (proper-do-exit? source)))
 2557(define (define-expr? source env)
 2558  (and (mymatch define-sym -1 source)
 2559       (proper-definition? source env)
 2560       (let ((v (definition-variable source)))
 2561         (not-macro v env (source-code v)))))
 2562(define (combination-expr? source)
 2563  (let ((length (proper-length (source-code source))))
 2564    (if length
 2565        (or (> length 0) (pt-syntax-error source "Ill-formed procedure call"))
 2566        (pt-syntax-error source "Ill-terminated procedure call"))))
 2567(define (delay-expr? source env)
 2568  (and (not (eq? (scheme-dialect (env-declarations env)) ieee-scheme-sym))
 2569       (mymatch delay-sym 1 source)))
 2570(define (future-expr? source env)
 2571  (and (eq? (scheme-dialect (env-declarations env)) multilisp-sym)
 2572       (mymatch future-sym 1 source)))
 2573(define (macro-expr? source env)
 2574  (let ((code (source-code source)))
 2575    (and (pair? code)
 2576         (symbol-object? (source-code (car code)))
 2577         (let ((macr (env-lookup-macro env (source-code (car code)))))
 2578           (and macr
 2579                (let ((len (proper-length (cdr code))))
 2580                  (if len
 2581                      (let ((len* (+ len 1)) (size (car macr)))
 2582                        (or (if (> size 0) (= len* size) (>= len* (- size)))
 2583                            (pt-syntax-error source "Ill-formed macro form")))
 2584                      (pt-syntax-error
 2585                       source
 2586                       "Ill-terminated macro form"))))))))
 2587(define (define-macro-expr? source env)
 2588  (and (mymatch **define-macro-sym -1 source) (proper-definition? source env)))
 2589(define (declare-expr? source) (mymatch **declare-sym -1 source))
 2590(define (include-expr? source) (mymatch **include-sym 1 source))
 2591(define (begin-defs-expr? source) (mymatch begin-sym 0 source))
 2592(define (mymatch keyword size source)
 2593  (let ((code (source-code source)))
 2594    (and (pair? code)
 2595         (eq? (source-code (car code)) keyword)
 2596         (let ((length (proper-length (cdr code))))
 2597           (if length
 2598               (or (if (> size 0) (= length size) (>= length (- size)))
 2599                   (pt-syntax-error source "Ill-formed special form" keyword))
 2600               (pt-syntax-error
 2601                source
 2602                "Ill-terminated special form"
 2603                keyword))))))
 2604(define (proper-length l)
 2605  (define (length l n)
 2606    (cond ((pair? l) (length (cdr l) (+ n 1))) ((null? l) n) (else #f)))
 2607  (length l 0))
 2608(define (proper-definition? source env)
 2609  (let* ((code (source-code source))
 2610         (pattern* (cadr code))
 2611         (pattern (source-code pattern*))
 2612         (body (cddr code)))
 2613    (cond ((bindable-var? pattern* env)
 2614           (cond ((length? body 0) #t)
 2615                 ((length? body 1) #t)
 2616                 (else (pt-syntax-error source "Ill-formed definition body"))))
 2617          ((pair? pattern)
 2618           (if (length? body 0)
 2619               (pt-syntax-error
 2620                source
 2621                "Body of a definition must have at least one expression"))
 2622           (if (bindable-var? (car pattern) env)
 2623               (proper-parms? (cdr pattern) env)
 2624               (pt-syntax-error
 2625                (car pattern)
 2626                "Procedure name must be an identifier")))
 2627          (else (pt-syntax-error pattern* "Ill-formed definition pattern")))))
 2628(define (definition-variable def)
 2629  (let* ((code (source-code def)) (pattern (cadr code)))
 2630    (if (pair? (source-code pattern)) (car (source-code pattern)) pattern)))
 2631(define (definition-value def)
 2632  (let ((code (source-code def)) (loc (source-locat def)))
 2633    (cond ((pair? (source-code (cadr code)))
 2634           (make-source
 2635            (cons (make-source lambda-sym loc)
 2636                  (cons (parms->source (cdr (source-code (cadr code))) loc)
 2637                        (cddr code)))
 2638            loc))
 2639          ((null? (cddr code))
 2640           (make-source
 2641            (list (make-source quote-sym loc) (make-source undef-object loc))
 2642            loc))
 2643          (else (caddr code)))))
 2644(define (parms->source parms loc)
 2645  (if (or (pair? parms) (null? parms)) (make-source parms loc) parms))
 2646(define (proper-parms? parms env)
 2647  (define (proper-parms parms seen optional-seen)
 2648    (cond ((pair? parms)
 2649           (let* ((parm* (car parms)) (parm (source-code parm*)))
 2650             (cond ((pair? parm)
 2651                    (if (eq? (scheme-dialect (env-declarations env))
 2652                             multilisp-sym)
 2653                        (let ((length (proper-length parm)))
 2654                          (if (or (eqv? length 1) (eqv? length 2))
 2655                              (let ((var (car parm)))
 2656                                (if (bindable-var? var env)
 2657                                    (if (memq (source-code var) seen)
 2658                                        (pt-syntax-error
 2659                                         var
 2660                                         "Duplicate parameter in parameter list")
 2661                                        (proper-parms
 2662                                         (cdr parms)
 2663                                         (cons (source-code var) seen)
 2664                                         #t))
 2665                                    (pt-syntax-error
 2666                                     var
 2667                                     "Parameter must be an identifier")))
 2668                              (pt-syntax-error
 2669                               parm*
 2670                               "Ill-formed optional parameter")))
 2671                        (pt-syntax-error
 2672                         parm*
 2673                         "optional parameters illegal in this dialect")))
 2674                   (optional-seen
 2675                    (pt-syntax-error parm* "Optional parameter expected"))
 2676                   ((bindable-var? parm* env)
 2677                    (if (memq parm seen)
 2678                        (pt-syntax-error
 2679                         parm*
 2680                         "Duplicate parameter in parameter list"))
 2681                    (proper-parms (cdr parms) (cons parm seen) #f))
 2682                   (else
 2683                    (pt-syntax-error
 2684                     parm*
 2685                     "Parameter must be an identifier")))))
 2686          ((null? parms) #t)
 2687          ((bindable-var? parms env)
 2688           (if (memq (source-code parms) seen)
 2689               (pt-syntax-error parms "Duplicate parameter in parameter list")
 2690               #t))
 2691          (else
 2692           (pt-syntax-error parms "Rest parameter must be an identifier"))))
 2693  (proper-parms parms '() #f))
 2694(define (proper-clauses? source)
 2695  (define (proper-clauses clauses)
 2696    (or (null? clauses)
 2697        (let* ((clause* (car clauses))
 2698               (clause (source-code clause*))
 2699               (length (proper-length clause)))
 2700          (if length
 2701              (if (>= length 1)
 2702                  (if (eq? (source-code (car clause)) else-sym)
 2703                      (cond ((= length 1)
 2704                             (pt-syntax-error
 2705                              clause*
 2706                              "Else clause must have a body"))
 2707                            ((not (null? (cdr clauses)))
 2708                             (pt-syntax-error
 2709                              clause*
 2710                              "Else clause must be the last clause"))
 2711                            (else (proper-clauses (cdr clauses))))
 2712                      (if (and (>= length 2)
 2713                               (eq? (source-code (cadr clause)) =>-sym)
 2714                               (not (= length 3)))
 2715                          (pt-syntax-error
 2716                           (cadr clause)
 2717                           "'=>' must be followed by a single expression")
 2718                          (proper-clauses (cdr clauses))))
 2719                  (pt-syntax-error clause* "Ill-formed 'cond' clause"))
 2720              (pt-syntax-error clause* "Ill-terminated 'cond' clause")))))
 2721  (proper-clauses (cdr (source-code source))))
 2722(define (proper-case-clauses? source)
 2723  (define (proper-case-clauses clauses)
 2724    (or (null? clauses)
 2725        (let* ((clause* (car clauses))
 2726               (clause (source-code clause*))
 2727               (length (proper-length clause)))
 2728          (if length
 2729              (if (>= length 2)
 2730                  (if (eq? (source-code (car clause)) else-sym)
 2731                      (if (not (null? (cdr clauses)))
 2732                          (pt-syntax-error
 2733                           clause*
 2734                           "Else clause must be the last clause")
 2735                          (proper-case-clauses (cdr clauses)))
 2736                      (begin
 2737                        (proper-selector-list? (car clause))
 2738                        (proper-case-clauses (cdr clauses))))
 2739                  (pt-syntax-error
 2740                   clause*
 2741                   "A 'case' clause must have a selector list and a body"))
 2742              (pt-syntax-error clause* "Ill-terminated 'case' clause")))))
 2743  (proper-case-clauses (cddr (source-code source))))
 2744(define (proper-selector-list? source)
 2745  (let* ((code (source-code source)) (length (proper-length code)))
 2746    (if length
 2747        (or (>= length 1)
 2748            (pt-syntax-error
 2749             source
 2750             "Selector list must contain at least one element"))
 2751        (pt-syntax-error source "Ill-terminated selector list"))))
 2752(define (proper-bindings? bindings check-dupl? env)
 2753  (define (proper-bindings l seen)
 2754    (cond ((pair? l)
 2755           (let* ((binding* (car l)) (binding (source-code binding*)))
 2756             (if (eqv? (proper-length binding) 2)
 2757                 (let ((var (car binding)))
 2758                   (if (bindable-var? var env)
 2759                       (if (and check-dupl? (memq (source-code var) seen))
 2760                           (pt-syntax-error
 2761                            var
 2762                            "Duplicate variable in bindings")
 2763                           (proper-bindings
 2764                            (cdr l)
 2765                            (cons (source-code var) seen)))
 2766                       (pt-syntax-error
 2767                        var
 2768                        "Binding variable must be an identifier")))
 2769                 (pt-syntax-error binding* "Ill-formed binding"))))
 2770          ((null? l) #t)
 2771          (else (pt-syntax-error bindings "Ill-terminated binding list"))))
 2772  (proper-bindings (source-code bindings) '()))
 2773(define (proper-do-bindings? source env)
 2774  (let ((bindings (cadr (source-code source))))
 2775    (define (proper-bindings l seen)
 2776      (cond ((pair? l)
 2777             (let* ((binding* (car l))
 2778                    (binding (source-code binding*))
 2779                    (length (proper-length binding)))
 2780               (if (or (eqv? length 2) (eqv? length 3))
 2781                   (let ((var (car binding)))
 2782                     (if (bindable-var? var env)
 2783                         (if (memq (source-code var) seen)
 2784                             (pt-syntax-error
 2785                              var
 2786                              "Duplicate variable in bindings")
 2787                             (proper-bindings
 2788                              (cdr l)
 2789                              (cons (source-code var) seen)))
 2790                         (pt-syntax-error
 2791                          var
 2792                          "Binding variable must be an identifier")))
 2793                   (pt-syntax-error binding* "Ill-formed binding"))))
 2794            ((null? l) #t)
 2795            (else (pt-syntax-error bindings "Ill-terminated binding list"))))
 2796    (proper-bindings (source-code bindings) '())))
 2797(define (proper-do-exit? source)
 2798  (let* ((code (source-code (caddr (source-code source))))
 2799         (length (proper-length code)))
 2800    (if length
 2801        (or (> length 0) (pt-syntax-error source "Ill-formed exit clause"))
 2802        (pt-syntax-error source "Ill-terminated exit clause"))))
 2803(define (include-filename source) (source-code (cadr (source-code source))))
 2804(define (begin-defs-body source) (cdr (source-code source)))
 2805(define (length? l n)
 2806  (cond ((null? l) (= n 0)) ((> n 0) (length? (cdr l) (- n 1))) (else #f)))
 2807(define (transform-declaration source)
 2808  (let ((code (source-code source)))
 2809    (if (not (pair? code))
 2810        (pt-syntax-error source "Ill-formed declaration")
 2811        (let* ((pos (not (eq? (source-code (car code)) not-sym)))
 2812               (x (if pos code (cdr code))))
 2813          (if (not (pair? x))
 2814              (pt-syntax-error source "Ill-formed declaration")
 2815              (let* ((id* (car x)) (id (source-code id*)))
 2816                (cond ((not (symbol-object? id))
 2817                       (pt-syntax-error
 2818                        id*
 2819                        "Declaration name must be an identifier"))
 2820                      ((assq id flag-declarations)
 2821                       (cond ((not pos)
 2822                              (pt-syntax-error
 2823                               id*
 2824                               "Declaration can't be negated"))
 2825                             ((null? (cdr x))
 2826                              (flag-decl
 2827                               source
 2828                               (cdr (assq id flag-declarations))
 2829                               id))
 2830                             (else
 2831                              (pt-syntax-error
 2832                               source
 2833                               "Ill-formed declaration"))))
 2834                      ((memq id parameterized-declarations)
 2835                       (cond ((not pos)
 2836                              (pt-syntax-error
 2837                               id*
 2838                               "Declaration can't be negated"))
 2839                             ((eqv? (proper-length x) 2)
 2840                              (parameterized-decl
 2841                               source
 2842                               id
 2843                               (source->expression (cadr x))))
 2844                             (else
 2845                              (pt-syntax-error
 2846                               source
 2847                               "Ill-formed declaration"))))
 2848                      ((memq id boolean-declarations)
 2849                       (if (null? (cdr x))
 2850                           (boolean-decl source id pos)
 2851                           (pt-syntax-error source "Ill-formed declaration")))
 2852                      ((assq id namable-declarations)
 2853                       (cond ((not pos)
 2854                              (pt-syntax-error
 2855                               id*
 2856                               "Declaration can't be negated"))
 2857                             (else
 2858                              (namable-decl
 2859                               source
 2860                               (cdr (assq id namable-declarations))
 2861                               id
 2862                               (map source->expression (cdr x))))))
 2863                      ((memq id namable-boolean-declarations)
 2864                       (namable-boolean-decl
 2865                        source
 2866                        id
 2867                        pos
 2868                        (map source->expression (cdr x))))
 2869                      ((memq id namable-string-declarations)
 2870                       (if (not (pair? (cdr x)))
 2871                           (pt-syntax-error source "Ill-formed declaration")
 2872                           (let* ((str* (cadr x)) (str (source-code str*)))
 2873                             (cond ((not pos)
 2874                                    (pt-syntax-error
 2875                                     id*
 2876                                     "Declaration can't be negated"))
 2877                                   ((not (string? str))
 2878                                    (pt-syntax-error str* "String expected"))
 2879                                   (else
 2880                                    (namable-string-decl
 2881                                     source
 2882                                     id
 2883                                     str
 2884                                     (map source->expression (cddr x))))))))
 2885                      (else (pt-syntax-error id* "Unknown declaration")))))))))
 2886(define (add-declarations source env)
 2887  (let loop ((l (cdr (source-code source))) (env env))
 2888    (if (pair? l)
 2889        (loop (cdr l) (env-declare env (transform-declaration (car l))))
 2890        env)))
 2891(define (add-decl d decl) (env-declare decl d))
 2892(define (add-macro source env)
 2893  (define (form-size parms)
 2894    (let loop ((l parms) (n 1))
 2895      (if (pair? l) (loop (cdr l) (+ n 1)) (if (null? l) n (- n)))))
 2896  (define (error-proc . msgs)
 2897    (apply compiler-user-error
 2898           (cons (source-locat source) (cons "(in macro body)" msgs))))
 2899  (let ((var (definition-variable source)) (proc (definition-value source)))
 2900    (if (lambda-expr? proc env)
 2901        (env-macro
 2902         env
 2903         (source-code var)
 2904         (cons (form-size (source->parms (cadr (source-code proc))))
 2905               (scheme-global-eval (source->expression proc) error-proc)))
 2906        (pt-syntax-error source "Macro value must be a lambda expression"))))
 2907(define (ptree.begin! info-port) (set! *ptree-port* info-port) '())
 2908(define (ptree.end!) '())
 2909(define *ptree-port* '())
 2910(define (normalize-parse-tree ptree env)
 2911  (define (normalize ptree)
 2912    (let ((tree (assignment-convert (partial-evaluate ptree) env)))
 2913      (lambda-lift! tree)
 2914      tree))
 2915  (if (def? ptree)
 2916      (begin
 2917        (node-children-set! ptree (list (normalize (def-val ptree))))
 2918        ptree)
 2919      (normalize ptree)))
 2920(define (partial-evaluate ptree) (pe ptree '()))
 2921(define (pe ptree consts)
 2922  (cond ((cst? ptree)
 2923         (new-cst (node-source ptree) (node-decl ptree) (cst-val ptree)))
 2924        ((ref? ptree)
 2925         (let ((var (ref-var ptree)))
 2926           (var-refs-set! var (set-remove (var-refs var) ptree))
 2927           (let ((x (assq var consts)))
 2928             (if x
 2929                 (new-cst (node-source ptree) (node-decl ptree) (cdr x))
 2930                 (let ((y (global-val var)))
 2931                   (if (and y (cst? y))
 2932                       (new-cst (node-source ptree)
 2933                                (node-decl ptree)
 2934                                (cst-val y))
 2935                       (new-ref (node-source ptree)
 2936                                (node-decl ptree)
 2937                                var)))))))
 2938        ((set? ptree)
 2939         (let ((var (set-var ptree)) (val (pe (set-val ptree) consts)))
 2940           (var-sets-set! var (set-remove (var-sets var) ptree))
 2941           (new-set (node-source ptree) (node-decl ptree) var val)))
 2942        ((tst? ptree)
 2943         (let ((pre (pe (tst-pre ptree) consts)))
 2944           (if (cst? pre)
 2945               (let ((val (cst-val pre)))
 2946                 (if (false-object? val)
 2947                     (pe (tst-alt ptree) consts)
 2948                     (pe (tst-con ptree) consts)))
 2949               (new-tst (node-source ptree)
 2950                        (node-decl ptree)
 2951                        pre
 2952                        (pe (tst-con ptree) consts)
 2953                        (pe (tst-alt ptree) consts)))))
 2954        ((conj? ptree)
 2955         (let ((pre (pe (conj-pre ptree) consts)))
 2956           (if (cst? pre)
 2957               (let ((val (cst-val pre)))
 2958                 (if (false-object? val) pre (pe (conj-alt ptree) consts)))
 2959               (new-conj
 2960                (node-source ptree)
 2961                (node-decl ptree)
 2962                pre
 2963                (pe (conj-alt ptree) consts)))))
 2964        ((disj? ptree)
 2965         (let ((pre (pe (disj-pre ptree) consts)))
 2966           (if (cst? pre)
 2967               (let ((val (cst-val pre)))
 2968                 (if (false-object? val) (pe (disj-alt ptree) consts) pre))
 2969               (new-disj
 2970                (node-source ptree)
 2971                (node-decl ptree)
 2972                pre
 2973                (pe (disj-alt ptree) consts)))))
 2974        ((prc? ptree)
 2975         (new-prc (node-source ptree)
 2976                  (node-decl ptree)
 2977                  (prc-name ptree)
 2978                  (prc-min ptree)
 2979                  (prc-rest ptree)
 2980                  (prc-parms ptree)
 2981                  (pe (prc-body ptree) consts)))
 2982        ((app? ptree)
 2983         (let ((oper (app-oper ptree)) (args (app-args ptree)))
 2984           (if (and (prc? oper)
 2985                    (not (prc-rest oper))
 2986                    (= (length (prc-parms oper)) (length args)))
 2987               (pe-let ptree consts)
 2988               (new-call
 2989                (node-source ptree)
 2990                (node-decl ptree)
 2991                (pe oper consts)
 2992                (map (lambda (x) (pe x consts)) args)))))
 2993        ((fut? ptree)
 2994         (new-fut (node-source ptree)
 2995                  (node-decl ptree)
 2996                  (pe (fut-val ptree) consts)))
 2997        (else (compiler-internal-error "pe, unknown parse tree node type"))))
 2998(define (pe-let ptree consts)
 2999  (let* ((proc (app-oper ptree))
 3000         (vals (app-args ptree))
 3001         (vars (prc-parms proc))
 3002         (non-mut-vars (set-keep not-mutable? (list->set vars))))
 3003    (for-each
 3004     (lambda (var)
 3005       (var-refs-set! var (set-empty))
 3006       (var-sets-set! var (set-empty)))
 3007     vars)
 3008    (let loop ((l vars)
 3009               (v vals)
 3010               (new-vars '())
 3011               (new-vals '())
 3012               (new-consts consts))
 3013      (if (null? l)
 3014          (if (null? new-vars)
 3015              (pe (prc-body proc) new-consts)
 3016              (new-call
 3017               (node-source ptree)
 3018               (node-decl ptree)
 3019               (new-prc (node-source proc)
 3020                        (node-decl proc)
 3021                        #f
 3022                        (length new-vars)
 3023                        #f
 3024                        (reverse new-vars)
 3025                        (pe (prc-body proc) new-consts))
 3026               (reverse new-vals)))
 3027          (let ((var (car l)) (val (pe (car v) consts)))
 3028            (if (and (set-member? var non-mut-vars) (cst? val))
 3029                (loop (cdr l)
 3030                      (cdr v)
 3031                      new-vars
 3032                      new-vals
 3033                      (cons (cons var (cst-val val)) new-consts))
 3034                (loop (cdr l)
 3035                      (cdr v)
 3036                      (cons var new-vars)
 3037                      (cons val new-vals)
 3038                      new-consts)))))))
 3039(define (assignment-convert ptree env)
 3040  (ac ptree (env-declare env (list safe-sym #f)) '()))
 3041(define (ac ptree env mut)
 3042  (cond ((cst? ptree) ptree)
 3043        ((ref? ptree)
 3044         (let ((var (ref-var ptree)))
 3045           (if (global? var)
 3046               ptree
 3047               (let ((x (assq var mut)))
 3048                 (if x
 3049                     (let ((source (node-source ptree)))
 3050                       (var-refs-set! var (set-remove (var-refs var) ptree))
 3051                       (new-call
 3052                        source
 3053                        (node-decl ptree)
 3054                        (new-ref-extended-bindings source **cell-ref-sym env)
 3055                        (list (new-ref source (node-decl ptree) (cdr x)))))
 3056                     ptree)))))
 3057        ((set? ptree)
 3058         (let ((var (set-var ptree))
 3059               (source (node-source ptree))
 3060               (val (ac (set-val ptree) env mut)))
 3061           (var-sets-set! var (set-remove (var-sets var) ptree))
 3062           (if (global? var)
 3063               (new-set source (node-decl ptree) var val)
 3064               (new-call
 3065                source
 3066                (node-decl ptree)
 3067                (new-ref-extended-bindings source **cell-set!-sym env)
 3068                (list (new-ref source (node-decl ptree) (cdr (assq var mut)))
 3069                      val)))))
 3070        ((tst? ptree)
 3071         (new-tst (node-source ptree)
 3072                  (node-decl ptree)
 3073                  (ac (tst-pre ptree) env mut)
 3074                  (ac (tst-con ptree) env mut)
 3075                  (ac (tst-alt ptree) env mut)))
 3076        ((conj? ptree)
 3077         (new-conj
 3078          (node-source ptree)
 3079          (node-decl ptree)
 3080          (ac (conj-pre ptree) env mut)
 3081          (ac (conj-alt ptree) env mut)))
 3082        ((disj? ptree)
 3083         (new-disj
 3084          (node-source ptree)
 3085          (node-decl ptree)
 3086          (ac (disj-pre ptree) env mut)
 3087          (ac (disj-alt ptree) env mut)))
 3088        ((prc? ptree) (ac-proc ptree env mut))
 3089        ((app? ptree)
 3090         (let ((oper (app-oper ptree)) (args (app-args ptree)))
 3091           (if (and (prc? oper)
 3092                    (not (prc-rest oper))
 3093                    (= (length (prc-parms oper)) (length args)))
 3094               (ac-let ptree env mut)
 3095               (new-call
 3096                (node-source ptree)
 3097                (node-decl ptree)
 3098                (ac oper env mut)
 3099                (map (lambda (x) (ac x env mut)) args)))))
 3100        ((fut? ptree)
 3101         (new-fut (node-source ptree)
 3102                  (node-decl ptree)
 3103                  (ac (fut-val ptree) env mut)))
 3104        (else (compiler-internal-error "ac, unknown parse tree node type"))))
 3105(define (ac-proc ptree env mut)
 3106  (let* ((mut-parms (ac-mutables (prc-parms ptree)))
 3107         (mut-parms-copies (map var-copy mut-parms))
 3108         (mut (append (pair-up mut-parms mut-parms-copies) mut))
 3109         (new-body (ac (prc-body ptree) env mut)))
 3110    (new-prc (node-source ptree)
 3111             (node-decl ptree)
 3112             (prc-name ptree)
 3113             (prc-min ptree)
 3114             (prc-rest ptree)
 3115             (prc-parms ptree)
 3116             (if (null? mut-parms)
 3117                 new-body
 3118                 (new-call
 3119                  (node-source ptree)
 3120                  (node-decl ptree)
 3121                  (new-prc (node-source ptree)
 3122                           (node-decl ptree)
 3123                           #f
 3124                           (length mut-parms-copies)
 3125                           #f
 3126                           mut-parms-copies
 3127                           new-body)
 3128                  (map (lambda (var)
 3129                         (new-call
 3130                          (var-source var)
 3131                          (node-decl ptree)
 3132                          (new-ref-extended-bindings
 3133                           (var-source var)
 3134                           **make-cell-sym
 3135                           env)
 3136                          (list (new-ref (var-source var)
 3137                                         (node-decl ptree)
 3138                                         var))))
 3139                       mut-parms))))))
 3140(define (ac-let ptree env mut)
 3141  (let* ((proc (app-oper ptree))
 3142         (vals (app-args ptree))
 3143         (vars (prc-parms proc))
 3144         (vals-fv (apply set-union (map free-variables vals)))
 3145         (mut-parms (ac-mutables vars))
 3146         (mut-parms-copies (map var-copy mut-parms))
 3147         (mut (append (pair-up mut-parms mut-parms-copies) mut)))
 3148    (let loop ((l vars)
 3149               (v vals)
 3150               (new-vars '())
 3151               (new-vals '())
 3152               (new-body (ac (prc-body proc) env mut)))
 3153      (if (null? l)
 3154          (new-let ptree proc new-vars new-vals new-body)
 3155          (let ((var (car l)) (val (car v)))
 3156            (if (memq var mut-parms)
 3157                (let ((src (node-source val))
 3158                      (decl (node-decl val))
 3159                      (var* (cdr (assq var mut))))
 3160                  (if (set-member? var vals-fv)
 3161                      (loop (cdr l)
 3162                            (cdr v)
 3163                            (cons var* new-vars)
 3164                            (cons (new-call
 3165                                   src
 3166                                   decl
 3167                                   (new-ref-extended-bindings
 3168                                    src
 3169                                    **make-cell-sym
 3170                                    env)
 3171                                   (list (new-cst src decl undef-object)))
 3172                                  new-vals)
 3173                            (new-seq src
 3174                                     decl
 3175                                     (new-call
 3176                                      src
 3177                                      decl
 3178                                      (new-ref-extended-bindings
 3179                                       src
 3180                                       **cell-set!-sym
 3181                                       env)
 3182                                      (list (new-ref src decl var*)
 3183                                            (ac val env mut)))
 3184                                     new-body))
 3185                      (loop (cdr l)
 3186                            (cdr v)
 3187                            (cons var* new-vars)
 3188                            (cons (new-call
 3189                                   src
 3190                                   decl
 3191                                   (new-ref-extended-bindings
 3192                                    src
 3193                                    **make-cell-sym
 3194                                    env)
 3195                                   (list (ac val env mut)))
 3196                                  new-vals)
 3197                            new-body)))
 3198                (loop (cdr l)
 3199                      (cdr v)
 3200                      (cons var new-vars)
 3201                      (cons (ac val env mut) new-vals)
 3202                      new-body)))))))
 3203(define (ac-mutables l)
 3204  (if (pair? l)
 3205      (let ((var (car l)) (rest (ac-mutables (cdr l))))
 3206        (if (mutable? var) (cons var rest) rest))
 3207      '()))
 3208(define (lambda-lift! ptree) (ll! ptree (set-empty) '()))
 3209(define (ll! ptree cst-procs env)
 3210  (define (new-env env vars)
 3211    (define (loop i l)
 3212      (if (pair? l)
 3213          (let ((var (car l)))
 3214            (cons (cons var (cons (length (set->list (var-refs var))) i))
 3215                  (loop (+ i 1) (cdr l))))
 3216          env))
 3217    (loop (length env) vars))
 3218  (cond ((or (cst? ptree)
 3219             (ref? ptree)
 3220             (set? ptree)
 3221             (tst? ptree)
 3222             (conj? ptree)
 3223             (disj? ptree)
 3224             (fut? ptree))
 3225         (for-each
 3226          (lambda (child) (ll! child cst-procs env))
 3227          (node-children ptree)))
 3228        ((prc? ptree)
 3229         (ll! (prc-body ptree) cst-procs (new-env env (prc-parms ptree))))
 3230        ((app? ptree)
 3231         (let ((oper (app-oper ptree)) (args (app-args ptree)))
 3232           (if (and (prc? oper)
 3233                    (not (prc-rest oper))
 3234                    (= (length (prc-parms oper)) (length args)))
 3235               (ll!-let ptree cst-procs (new-env env (prc-parms oper)))
 3236               (for-each
 3237                (lambda (child) (ll! child cst-procs env))
 3238                (node-children ptree)))))
 3239        (else (compiler-internal-error "ll!, unknown parse tree node type"))))
 3240(define (ll!-let ptree cst-procs env)
 3241  (let* ((proc (app-oper ptree))
 3242         (vals (app-args ptree))
 3243         (vars (prc-parms proc))
 3244         (var-val-map (pair-up vars vals)))
 3245    (define (var->val var) (cdr (assq var var-val-map)))
 3246    (define (liftable-proc-vars vars)
 3247      (let loop ((cst-proc-vars
 3248                  (set-keep
 3249                   (lambda (var)
 3250                     (let ((val (var->val var)))
 3251                       (and (prc? val)
 3252                            (lambda-lift? (node-decl val))
 3253                            (set-every? oper-pos? (var-refs var)))))
 3254                   (list->set vars))))
 3255        (let* ((non-cst-proc-vars
 3256                (set-keep
 3257                 (lambda (var)
 3258                   (let ((val (var->val var)))
 3259                     (and (prc? val) (not (set-member? var cst-proc-vars)))))
 3260                 (list->set vars)))
 3261               (cst-proc-vars*
 3262                (set-keep
 3263                 (lambda (var)
 3264                   (let ((val (var->val var)))
 3265                     (set-empty?
 3266                      (set-intersection
 3267                       (free-variables val)
 3268                       non-cst-proc-vars))))
 3269                 cst-proc-vars)))
 3270          (if (set-equal? cst-proc-vars cst-proc-vars*)
 3271              cst-proc-vars
 3272              (loop cst-proc-vars*)))))
 3273    (define (transitively-closed-free-variables vars)
 3274      (let ((tcfv-map
 3275             (map (lambda (var) (cons var (free-variables (var->val var))))
 3276                  vars)))
 3277        (let loop ((changed? #f))
 3278          (for-each
 3279           (lambda (var-tcfv)
 3280             (let loop2 ((l (set->list (cdr var-tcfv))) (fv (cdr var-tcfv)))
 3281               (if (null? l)
 3282                   (if (not (set-equal? fv (cdr var-tcfv)))
 3283                       (begin (set-cdr! var-tcfv fv) (set! changed? #t)))
 3284                   (let ((x (assq (car l) tcfv-map)))
 3285                     (loop2 (cdr l) (if x (set-union fv (cdr x)) fv))))))
 3286           tcfv-map)
 3287          (if changed? (loop #f) tcfv-map))))
 3288    (let* ((tcfv-map
 3289            (transitively-closed-free-variables (liftable-proc-vars vars)))
 3290           (cst-proc-vars-list (map car tcfv-map))
 3291           (cst-procs* (set-union (list->set cst-proc-vars-list) cst-procs)))
 3292      (define (var->tcfv var) (cdr (assq var tcfv-map)))
 3293      (define (order-vars vars)
 3294        (map car
 3295             (sort-list
 3296              (map (lambda (var) (assq var env)) vars)
 3297              (lambda (x y)
 3298                (if (= (cadr x) (cadr y))
 3299                    (< (cddr x) (cddr y))
 3300                    (< (cadr x) (cadr y)))))))
 3301      (define (lifted-vars var)
 3302        (order-vars (set->list (set-difference (var->tcfv var) cst-procs*))))
 3303      (define (lift-app! var)
 3304        (let* ((val (var->val var)) (vars (lifted-vars var)))
 3305          (define (new-ref* var)
 3306            (new-ref (var-source var) (node-decl val) var))
 3307          (if (not (null? vars))
 3308              (for-each
 3309               (lambda (oper)
 3310                 (let ((node (node-parent oper)))
 3311                   (node-children-set!
 3312                    node
 3313                    (cons (app-oper node)
 3314                          (append (map new-ref* vars) (app-args node))))))
 3315               (set->list (var-refs var))))))
 3316      (define (lift-prc! var)
 3317        (let* ((val (var->val var)) (vars (lifted-vars var)))
 3318          (if (not (null? vars))
 3319              (let ((var-copies (map var-copy vars)))
 3320                (prc-parms-set! val (append var-copies (prc-parms val)))
 3321                (for-each (lambda (x) (var-bound-set! x val)) var-copies)
 3322                (node-fv-invalidate! val)
 3323                (prc-min-set! val (+ (prc-min val) (length vars)))
 3324                (ll-rename! val (pair-up vars var-copies))))))
 3325      (for-each lift-app! cst-proc-vars-list)
 3326      (for-each lift-prc! cst-proc-vars-list)
 3327      (for-each (lambda (node) (ll! node cst-procs* env)) vals)
 3328      (ll! (prc-body proc) cst-procs* env))))
 3329(define (ll-rename! ptree var-map)
 3330  (cond ((ref? ptree)
 3331         (let* ((var (ref-var ptree)) (x (assq var var-map)))
 3332           (if x
 3333               (begin
 3334                 (var-refs-set! var (set-remove (var-refs var) ptree))
 3335                 (var-refs-set! (cdr x) (set-adjoin (var-refs (cdr x)) ptree))
 3336                 (ref-var-set! ptree (cdr x))))))
 3337        ((set? ptree)
 3338         (let* ((var (set-var ptree)) (x (assq var var-map)))
 3339           (if x
 3340               (begin
 3341                 (var-sets-set! var (set-remove (var-sets var) ptree))
 3342                 (var-sets-set! (cdr x) (set-adjoin (var-sets (cdr x)) ptree))
 3343                 (set-var-set! ptree (cdr x)))))))
 3344  (node-fv-set! ptree #t)
 3345  (for-each (lambda (child) (ll-rename! child var-map)) (node-children ptree)))
 3346(define (parse-tree->expression ptree) (se ptree '() (list 0)))
 3347(define (se ptree env num)
 3348  (cond ((cst? ptree) (list quote-sym (cst-val ptree)))
 3349        ((ref? ptree)
 3350         (let ((x (assq (ref-var ptree) env)))
 3351           (if x (cdr x) (var-name (ref-var ptree)))))
 3352        ((set? ptree)
 3353         (list set!-sym
 3354               (let ((x (assq (set-var ptree) env)))
 3355                 (if x (cdr x) (var-name (set-var ptree))))
 3356               (se (set-val ptree) env num)))
 3357        ((def? ptree)
 3358         (list define-sym
 3359               (let ((x (assq (def-var ptree) env)))
 3360                 (if x (cdr x) (var-name (def-var ptree))))
 3361               (se (def-val ptree) env num)))
 3362        ((tst? ptree)
 3363         (list if-sym
 3364               (se (tst-pre ptree) env num)
 3365               (se (tst-con ptree) env num)
 3366               (se (tst-alt ptree) env num)))
 3367        ((conj? ptree)
 3368         (list and-sym
 3369               (se (conj-pre ptree) env num)
 3370               (se (conj-alt ptree) env num)))
 3371        ((disj? ptree)
 3372         (list or-sym
 3373               (se (disj-pre ptree) env num)
 3374               (se (disj-alt ptree) env num)))
 3375        ((prc? ptree)
 3376         (let ((new-env (se-rename (prc-parms ptree) env num)))
 3377           (list lambda-sym
 3378                 (se-parameters
 3379                  (prc-parms ptree)
 3380                  (prc-rest ptree)
 3381                  (prc-min ptree)
 3382                  new-env)
 3383                 (se (prc-body ptree) new-env num))))
 3384        ((app? ptree)
 3385         (let ((oper (app-oper ptree)) (args (app-args ptree)))
 3386           (if (and (prc? oper)
 3387                    (not (prc-rest oper))
 3388                    (= (length (prc-parms oper)) (length args)))
 3389               (let ((new-env (se-rename (prc-parms oper) env num)))
 3390                 (list (if (set-empty?
 3391                            (set-intersection
 3392                             (list->set (prc-parms oper))
 3393                             (apply set-union (map free-variables args))))
 3394                           let-sym
 3395                           letrec-sym)
 3396                       (se-bindings (prc-parms oper) args new-env num)
 3397                       (se (prc-body oper) new-env num)))
 3398               (map (lambda (x) (se x env num)) (cons oper args)))))
 3399        ((fut? ptree) (list future-sym (se (fut-val ptree) env num)))
 3400        (else (compiler-internal-error "se, unknown parse tree node type"))))
 3401(define (se-parameters parms rest min env)
 3402  (define (se-parms parms rest n env)
 3403    (cond ((null? parms) '())
 3404          ((and rest (null? (cdr parms))) (cdr (assq (car parms) env)))
 3405          (else
 3406           (let ((parm (cdr (assq (car parms) env))))
 3407             (cons (if (> n 0) parm (list parm))
 3408                   (se-parms (cdr parms) rest (- n 1) env))))))
 3409  (se-parms parms rest min env))
 3410(define (se-bindings vars vals env num)
 3411  (if (null? vars)
 3412      '()
 3413      (cons (list (cdr (assq (car vars) env)) (se (car vals) env num))
 3414            (se-bindings (cdr vars) (cdr vals) env num))))
 3415(define (se-rename vars env num)
 3416  (define (rename vars)
 3417    (if (null? vars)
 3418        env
 3419        (cons (cons (car vars)
 3420                    (string->canonical-symbol
 3421                     (string-append
 3422                      (symbol->string (var-name (car vars)))
 3423                      "#"
 3424                      (number->string (car num)))))
 3425              (rename (cdr vars)))))
 3426  (set-car! num (+ (car num) 1))
 3427  (rename vars))
 3428(define *opnd-table* '())
 3429(define *opnd-table-alloc* '())
 3430(define opnd-table-size 10000)
 3431(define (enter-opnd arg1 arg2)
 3432  (let loop ((i 0))
 3433    (if (< i *opnd-table-alloc*)
 3434        (let ((x (vector-ref *opnd-table* i)))
 3435          (if (and (eqv? (car x) arg1) (eqv? (cdr x) arg2)) i (loop (+ i 1))))
 3436        (if (< *opnd-table-alloc* opnd-table-size)
 3437            (begin
 3438              (set! *opnd-table-alloc* (+ *opnd-table-alloc* 1))
 3439              (vector-set! *opnd-table* i (cons arg1 arg2))
 3440              i)
 3441            (compiler-limitation-error
 3442             "program is too long [virtual machine operand table overflow]")))))
 3443(define (contains-opnd? opnd1 opnd2)
 3444  (cond ((eqv? opnd1 opnd2) #t)
 3445        ((clo? opnd2) (contains-opnd? opnd1 (clo-base opnd2)))
 3446        (else #f)))
 3447(define (any-contains-opnd? opnd opnds)
 3448  (if (null? opnds)
 3449      #f
 3450      (or (contains-opnd? opnd (car opnds))
 3451          (any-contains-opnd? opnd (cdr opnds)))))
 3452(define (make-reg num) num)
 3453(define (reg? x) (< x 10000))
 3454(define (reg-num x) (modulo x 10000))
 3455(define (make-stk num) (+ num 10000))
 3456(define (stk? x) (= (quotient x 10000) 1))
 3457(define (stk-num x) (modulo x 10000))
 3458(define (make-glo name) (+ (enter-opnd name #t) 30000))
 3459(define (glo? x) (= (quotient x 10000) 3))
 3460(define (glo-name x) (car (vector-ref *opnd-table* (modulo x 10000))))
 3461(define (make-clo base index) (+ (enter-opnd base index) 40000))
 3462(define (clo? x) (= (quotient x 10000) 4))
 3463(define (clo-base x) (car (vector-ref *opnd-table* (modulo x 10000))))
 3464(define (clo-index x) (cdr (vector-ref *opnd-table* (modulo x 10000))))
 3465(define (make-lbl num) (+ num 20000))
 3466(define (lbl? x) (= (quotient x 10000) 2))
 3467(define (lbl-num x) (modulo x 10000))
 3468(define label-limit 9999)
 3469(define (make-obj val) (+ (enter-opnd val #f) 50000))
 3470(define (obj? x) (= (quotient x 10000) 5))
 3471(define (obj-val x) (car (vector-ref *opnd-table* (modulo x 10000))))
 3472(define (make-pcontext fs map) (vector fs map))
 3473(define (pcontext-fs x) (vector-ref x 0))
 3474(define (pcontext-map x) (vector-ref x 1))
 3475(define (make-frame size slots regs closed live)
 3476  (vector size slots regs closed live))
 3477(define (frame-size x) (vector-ref x 0))
 3478(define (frame-slots x) (vector-ref x 1))
 3479(define (frame-regs x) (vector-ref x 2))
 3480(define (frame-closed x) (vector-ref x 3))
 3481(define (frame-live x) (vector-ref x 4))
 3482(define (frame-eq? x y) (= (frame-size x) (frame-size y)))
 3483(define (frame-truncate frame nb-slots)
 3484  (let ((fs (frame-size frame)))
 3485    (make-frame
 3486     nb-slots
 3487     (nth-after (frame-slots frame) (- fs nb-slots))
 3488     (frame-regs frame)
 3489     (frame-closed frame)
 3490     (frame-live frame))))
 3491(define (frame-live? var frame)
 3492  (let ((live (frame-live frame)))
 3493    (if (eq? var closure-env-var)
 3494        (let ((closed (frame-closed frame)))
 3495          (if (or (set-member? var live)
 3496                  (not (set-empty?
 3497                        (set-intersection live (list->set closed)))))
 3498              closed
 3499              #f))
 3500        (if (set-member? var live) var #f))))
 3501(define (frame-first-empty-slot frame)
 3502  (let loop ((i 1) (s (reverse (frame-slots frame))))
 3503    (if (pair? s)
 3504        (if (frame-live? (car s) frame) (loop (+ i 1) (cdr s)) i)
 3505        i)))
 3506(define (make-proc-obj
 3507         name
 3508         primitive?
 3509         code
 3510         call-pat
 3511         side-effects?
 3512         strict-pat
 3513         type)
 3514  (let ((proc-obj
 3515         (vector proc-obj-tag
 3516                 name
 3517                 primitive?
 3518                 code
 3519                 call-pat
 3520                 #f
 3521                 #f
 3522                 #f
 3523                 side-effects?
 3524                 strict-pat
 3525                 type)))
 3526    (proc-obj-specialize-set! proc-obj (lambda (decls) proc-obj))
 3527    proc-obj))
 3528(define proc-obj-tag (list 'proc-obj))
 3529(define (proc-obj? x)
 3530  (and (vector? x)
 3531       (> (vector-length x) 0)
 3532       (eq? (vector-ref x 0) proc-obj-tag)))
 3533(define (proc-obj-name obj) (vector-ref obj 1))
 3534(define (proc-obj-primitive? obj) (vector-ref obj 2))
 3535(define (proc-obj-code obj) (vector-ref obj 3))
 3536(define (proc-obj-call-pat obj) (vector-ref obj 4))
 3537(define (proc-obj-test obj) (vector-ref obj 5))
 3538(define (proc-obj-inlinable obj) (vector-ref obj 6))
 3539(define (proc-obj-specialize obj) (vector-ref obj 7))
 3540(define (proc-obj-side-effects? obj) (vector-ref obj 8))
 3541(define (proc-obj-strict-pat obj) (vector-ref obj 9))
 3542(define (proc-obj-type obj) (vector-ref obj 10))
 3543(define (proc-obj-code-set! obj x) (vector-set! obj 3 x))
 3544(define (proc-obj-test-set! obj x) (vector-set! obj 5 x))
 3545(define (proc-obj-inlinable-set! obj x) (vector-set! obj 6 x))
 3546(define (proc-obj-specialize-set! obj x) (vector-set! obj 7 x))
 3547(define (make-pattern min-args nb-parms rest?)
 3548  (let loop ((x (if rest? (- nb-parms 1) (list nb-parms)))
 3549             (y (if rest? (- nb-parms 1) nb-parms)))
 3550    (let ((z (- y 1))) (if (< z min-args) x (loop (cons z x) z)))))
 3551(define (pattern-member? n pat)
 3552  (cond ((pair? pat) (if (= (car pat) n) #t (pattern-member? n (cdr pat))))
 3553        ((null? pat) #f)
 3554        (else (<= pat n))))
 3555(define (type-name type) (if (pair? type) (car type) type))
 3556(define (type-pot-fut? type) (pair? type))
 3557(define (make-bbs)
 3558  (vector (make-counter 1 label-limit bbs-limit-err) (queue-empty) '()))
 3559(define (bbs-limit-err)
 3560  (compiler-limitation-error "procedure is too long [too many labels]"))
 3561(define (bbs-lbl-counter bbs) (vector-ref bbs 0))
 3562(define (bbs-lbl-counter-set! bbs cntr) (vector-set! bbs 0 cntr))
 3563(define (bbs-bb-queue bbs) (vector-ref bbs 1))
 3564(define (bbs-bb-queue-set! bbs bbq) (vector-set! bbs 1 bbq))
 3565(define (bbs-entry-lbl-num bbs) (vector-ref bbs 2))
 3566(define (bbs-entry-lbl-num-set! bbs lbl-num) (vector-set! bbs 2 lbl-num))
 3567(define (bbs-new-lbl! bbs) ((bbs-lbl-counter bbs)))
 3568(define (lbl-num->bb lbl-num bbs)
 3569  (let loop ((bb-list (queue->list (bbs-bb-queue bbs))))
 3570    (if (= (bb-lbl-num (car bb-list)) lbl-num)
 3571        (car bb-list)
 3572        (loop (cdr bb-list)))))
 3573(define (make-bb label-instr bbs)
 3574  (let ((bb (vector label-instr (queue-empty) '() '() '())))
 3575    (queue-put! (vector-ref bbs 1) bb)
 3576    bb))
 3577(define (bb-lbl-num bb) (label-lbl-num (vector-ref bb 0)))
 3578(define (bb-label-type bb) (label-type (vector-ref bb 0)))
 3579(define (bb-label-instr bb) (vector-ref bb 0))
 3580(define (bb-label-instr-set! bb l) (vector-set! bb 0 l))
 3581(define (bb-non-branch-instrs bb) (queue->list (vector-ref bb 1)))
 3582(define (bb-non-branch-instrs-set! bb l) (vector-set! bb 1 (list->queue l)))
 3583(define (bb-branch-instr bb) (vector-ref bb 2))
 3584(define (bb-branch-instr-set! bb b) (vector-set! bb 2 b))
 3585(define (bb-references bb) (vector-ref bb 3))
 3586(define (bb-references-set! bb l) (vector-set! bb 3 l))
 3587(define (bb-precedents bb) (vector-ref bb 4))
 3588(define (bb-precedents-set! bb l) (vector-set! bb 4 l))
 3589(define (bb-entry-frame-size bb)
 3590  (frame-size (gvm-instr-frame (bb-label-instr bb))))
 3591(define (bb-exit-frame-size bb)
 3592  (frame-size (gvm-instr-frame (bb-branch-instr bb))))
 3593(define (bb-slots-gained bb)
 3594  (- (bb-exit-frame-size bb) (bb-entry-frame-size bb)))
 3595(define (bb-put-non-branch! bb gvm-instr)
 3596  (queue-put! (vector-ref bb 1) gvm-instr))
 3597(define (bb-put-branch! bb gvm-instr) (vector-set! bb 2 gvm-instr))
 3598(define (bb-add-reference! bb ref)
 3599  (if (not (memq ref (vector-ref bb 3)))
 3600      (vector-set! bb 3 (cons ref (vector-ref bb 3)))))
 3601(define (bb-add-precedent! bb prec)
 3602  (if (not (memq prec (vector-ref bb 4)))
 3603      (vector-set! bb 4 (cons prec (vector-ref bb 4)))))
 3604(define (bb-last-non-branch-instr bb)
 3605  (let ((non-branch-instrs (bb-non-branch-instrs bb)))
 3606    (if (null? non-branch-instrs)
 3607        (bb-label-instr bb)
 3608        (let loop ((l non-branch-instrs))
 3609          (if (pair? (cdr l)) (loop (cdr l)) (car l))))))
 3610(define (gvm-instr-type gvm-instr) (vector-ref gvm-instr 0))
 3611(define (gvm-instr-frame gvm-instr) (vector-ref gvm-instr 1))
 3612(define (gvm-instr-comment gvm-instr) (vector-ref gvm-instr 2))
 3613(define (make-label-simple lbl-num frame comment)
 3614  (vector 'label frame comment lbl-num 'simple))
 3615(define (make-label-entry lbl-num nb-parms min rest? closed? frame comment)
 3616  (vector 'label frame comment lbl-num 'entry nb-parms min rest? closed?))
 3617(define (make-label-return lbl-num frame comment)
 3618  (vector 'label frame comment lbl-num 'return))
 3619(define (make-label-task-entry lbl-num frame comment)
 3620  (vector 'label frame comment lbl-num 'task-entry))
 3621(define (make-label-task-return lbl-num frame comment)
 3622  (vector 'label frame comment lbl-num 'task-return))
 3623(define (label-lbl-num gvm-instr) (vector-ref gvm-instr 3))
 3624(define (label-lbl-num-set! gvm-instr n) (vector-set! gvm-instr 3 n))
 3625(define (label-type gvm-instr) (vector-ref gvm-instr 4))
 3626(define (label-entry-nb-parms gvm-instr) (vector-ref gvm-instr 5))
 3627(define (label-entry-min gvm-instr) (vector-ref gvm-instr 6))
 3628(define (label-entry-rest? gvm-instr) (vector-ref gvm-instr 7))
 3629(define (label-entry-closed? gvm-instr) (vector-ref gvm-instr 8))
 3630(define (make-apply prim opnds loc frame comment)
 3631  (vector 'apply frame comment prim opnds loc))
 3632(define (apply-prim gvm-instr) (vector-ref gvm-instr 3))
 3633(define (apply-opnds gvm-instr) (vector-ref gvm-instr 4))
 3634(define (apply-loc gvm-instr) (vector-ref gvm-instr 5))
 3635(define (make-copy opnd loc frame comment)
 3636  (vector 'copy frame comment opnd loc))
 3637(define (copy-opnd gvm-instr) (vector-ref gvm-instr 3))
 3638(define (copy-loc gvm-instr) (vector-ref gvm-instr 4))
 3639(define (make-close parms frame comment) (vector 'close frame comment parms))
 3640(define (close-parms gvm-instr) (vector-ref gvm-instr 3))
 3641(define (make-closure-parms loc lbl opnds) (vector loc lbl opnds))
 3642(define (closure-parms-loc x) (vector-ref x 0))
 3643(define (closure-parms-lbl x) (vector-ref x 1))
 3644(define (closure-parms-opnds x) (vector-ref x 2))
 3645(define (make-ifjump test opnds true false poll? frame comment)
 3646  (vector 'ifjump frame comment test opnds true false poll?))
 3647(define (ifjump-test gvm-instr) (vector-ref gvm-instr 3))
 3648(define (ifjump-opnds gvm-instr) (vector-ref gvm-instr 4))
 3649(define (ifjump-true gvm-instr) (vector-ref gvm-instr 5))
 3650(define (ifjump-false gvm-instr) (vector-ref gvm-instr 6))
 3651(define (ifjump-poll? gvm-instr) (vector-ref gvm-instr 7))
 3652(define (make-jump opnd nb-args poll? frame comment)
 3653  (vector 'jump frame comment opnd nb-args poll?))
 3654(define (jump-opnd gvm-instr) (vector-ref gvm-instr 3))
 3655(define (jump-nb-args gvm-instr) (vector-ref gvm-instr 4))
 3656(define (jump-poll? gvm-instr) (vector-ref gvm-instr 5))
 3657(define (first-class-jump? gvm-instr) (jump-nb-args gvm-instr))
 3658(define (make-comment) (cons 'comment '()))
 3659(define (comment-put! comment name val)
 3660  (set-cdr! comment (cons (cons name val) (cdr comment))))
 3661(define (comment-get comment name)
 3662  (and comment (let ((x (assq name (cdr comment)))) (if x (cdr x) #f))))
 3663(define (bbs-purify! bbs)
 3664  (let loop ()
 3665    (bbs-remove-jump-cascades! bbs)
 3666    (bbs-remove-dead-code! bbs)
 3667    (let* ((changed1? (bbs-remove-common-code! bbs))
 3668           (changed2? (bbs-remove-useless-jumps! bbs)))
 3669      (if (or changed1? changed2?) (loop) (bbs-order! bbs)))))
 3670(define (bbs-remove-jump-cascades! bbs)
 3671  (define (empty-bb? bb)
 3672    (and (eq? (bb-label-type bb) 'simple) (null? (bb-non-branch-instrs bb))))
 3673  (define (jump-to-non-entry-lbl? branch)
 3674    (and (eq? (gvm-instr-type branch) 'jump)
 3675         (not (first-class-jump? branch))
 3676         (jump-lbl? branch)))
 3677  (define (jump-cascade-to lbl-num fs poll? seen thunk)
 3678    (if (memq lbl-num seen)
 3679        (thunk lbl-num fs poll?)
 3680        (let ((bb (lbl-num->bb lbl-num bbs)))
 3681          (if (and (empty-bb? bb) (<= (bb-slots-gained bb) 0))
 3682              (let ((jump-lbl-num
 3683                     (jump-to-non-entry-lbl? (bb-branch-instr bb))))
 3684                (if jump-lbl-num
 3685                    (jump-cascade-to
 3686                     jump-lbl-num
 3687                     (+ fs (bb-slots-gained bb))
 3688                     (or poll? (jump-poll? (bb-branch-instr bb)))
 3689                     (cons lbl-num seen)
 3690                     thunk)
 3691                    (thunk lbl-num fs poll?)))
 3692              (thunk lbl-num fs poll?)))))
 3693  (define (equiv-lbl lbl-num seen)
 3694    (if (memq lbl-num seen)
 3695        lbl-num
 3696        (let ((bb (lbl-num->bb lbl-num bbs)))
 3697          (if (empty-bb? bb)
 3698              (let ((jump-lbl-num
 3699                     (jump-to-non-entry-lbl? (bb-branch-instr bb))))
 3700                (if (and jump-lbl-num
 3701                         (not (jump-poll? (bb-branch-instr bb)))
 3702                         (= (bb-slots-gained bb) 0))
 3703                    (equiv-lbl jump-lbl-num (cons lbl-num seen))
 3704                    lbl-num))
 3705              lbl-num))))
 3706  (define (remove-cascade! bb)
 3707    (let ((branch (bb-branch-instr bb)))
 3708      (case (gvm-instr-type branch)
 3709        ((ifjump)
 3710         (bb-put-branch!
 3711          bb
 3712          (make-ifjump
 3713           (ifjump-test branch)
 3714           (ifjump-opnds branch)
 3715           (equiv-lbl (ifjump-true branch) '())
 3716           (equiv-lbl (ifjump-false branch) '())
 3717           (ifjump-poll? branch)
 3718           (gvm-instr-frame branch)
 3719           (gvm-instr-comment branch))))
 3720        ((jump)
 3721         (if (not (first-class-jump? branch))
 3722             (let ((dest-lbl-num (jump-lbl? branch)))
 3723               (if dest-lbl-num
 3724                   (jump-cascade-to
 3725                    dest-lbl-num
 3726                    (frame-size (gvm-instr-frame branch))
 3727                    (jump-poll? branch)
 3728                    '()
 3729                    (lambda (lbl-num fs poll?)
 3730                      (let* ((dest-bb (lbl-num->bb lbl-num bbs))
 3731                             (last-branch (bb-branch-instr dest-bb)))
 3732                        (if (and (empty-bb? dest-bb)
 3733                                 (or (not poll?)
 3734                                     put-poll-on-ifjump?
 3735                                     (not (eq? (gvm-instr-type last-branch)
 3736                                               'ifjump))))
 3737                            (let* ((new-fs (+ fs (bb-slots-gained dest-bb)))
 3738                                   (new-frame
 3739                                    (frame-truncate
 3740                                     (gvm-instr-frame branch)
 3741                                     new-fs)))
 3742                              (define (adjust-opnd opnd)
 3743                                (cond ((stk? opnd)
 3744                                       (make-stk
 3745                                        (+ (- fs (bb-entry-frame-size dest-bb))
 3746                                           (stk-num opnd))))
 3747                                      ((clo? opnd)
 3748                                       (make-clo
 3749                                        (adjust-opnd (clo-base opnd))
 3750                                        (clo-index opnd)))
 3751                                      (else opnd)))
 3752                              (case (gvm-instr-type last-branch)
 3753                                ((ifjump)
 3754                                 (bb-put-branch!
 3755                                  bb
 3756                                  (make-ifjump
 3757                                   (ifjump-test last-branch)
 3758                                   (map adjust-opnd (ifjump-opnds last-branch))
 3759                                   (equiv-lbl (ifjump-true last-branch) '())
 3760                                   (equiv-lbl (ifjump-false last-branch) '())
 3761                                   (or poll? (ifjump-poll? last-branch))
 3762                                   new-frame
 3763                                   (gvm-instr-comment last-branch))))
 3764                                ((jump)
 3765                                 (bb-put-branch!
 3766                                  bb
 3767                                  (make-jump
 3768                                   (adjust-opnd (jump-opnd last-branch))
 3769                                   (jump-nb-args last-branch)
 3770                                   (or poll? (jump-poll? last-branch))
 3771                                   new-frame
 3772                                   (gvm-instr-comment last-branch))))
 3773                                (else
 3774                                 (compiler-internal-error
 3775                                  "bbs-remove-jump-cascades!, unknown branch type"))))
 3776                            (bb-put-branch!
 3777                             bb
 3778                             (make-jump
 3779                              (make-lbl lbl-num)
 3780                              (jump-nb-args branch)
 3781                              (or poll? (jump-poll? branch))
 3782                              (frame-truncate (gvm-instr-frame branch) fs)
 3783                              (gvm-instr-comment branch)))))))))))
 3784        (else
 3785         (compiler-internal-error
 3786          "bbs-remove-jump-cascades!, unknown branch type")))))
 3787  (for-each remove-cascade! (queue->list (bbs-bb-queue bbs))))
 3788(define (jump-lbl? branch)
 3789  (let ((opnd (jump-opnd branch))) (if (lbl? opnd) (lbl-num opnd) #f)))
 3790(define put-poll-on-ifjump? #f)
 3791(set! put-poll-on-ifjump? #t)
 3792(define (bbs-remove-dead-code! bbs)
 3793  (let ((new-bb-queue (queue-empty)) (scan-queue (queue-empty)))
 3794    (define (reachable ref bb)
 3795      (if bb (bb-add-reference! bb ref))
 3796      (if (not (memq ref (queue->list new-bb-queue)))
 3797          (begin
 3798            (bb-references-set! ref '())
 3799            (bb-precedents-set! ref '())
 3800            (queue-put! new-bb-queue ref)
 3801            (queue-put! scan-queue ref))))
 3802    (define (direct-jump to-bb from-bb)
 3803      (reachable to-bb from-bb)
 3804      (bb-add-precedent! to-bb from-bb))
 3805    (define (scan-instr gvm-instr bb)
 3806      (define (scan-opnd gvm-opnd)
 3807        (cond ((lbl? gvm-opnd)
 3808               (reachable (lbl-num->bb (lbl-num gvm-opnd) bbs) bb))
 3809              ((clo? gvm-opnd) (scan-opnd (clo-base gvm-opnd)))))
 3810      (case (gvm-instr-type gvm-instr)
 3811        ((label) '())
 3812        ((apply)
 3813         (for-each scan-opnd (apply-opnds gvm-instr))
 3814         (if (apply-loc gvm-instr) (scan-opnd (apply-loc gvm-instr))))
 3815        ((copy)
 3816         (scan-opnd (copy-opnd gvm-instr))
 3817         (scan-opnd (copy-loc gvm-instr)))
 3818        ((close)
 3819         (for-each
 3820          (lambda (parm)
 3821            (reachable (lbl-num->bb (closure-parms-lbl parm) bbs) bb)
 3822            (scan-opnd (closure-parms-loc parm))
 3823            (for-each scan-opnd (closure-parms-opnds parm)))
 3824          (close-parms gvm-instr)))
 3825        ((ifjump)
 3826         (for-each scan-opnd (ifjump-opnds gvm-instr))
 3827         (direct-jump (lbl-num->bb (ifjump-true gvm-instr) bbs) bb)
 3828         (direct-jump (lbl-num->bb (ifjump-false gvm-instr) bbs) bb))
 3829        ((jump)
 3830         (let ((opnd (jump-opnd gvm-instr)))
 3831           (if (lbl? opnd)
 3832               (direct-jump (lbl-num->bb (lbl-num opnd) bbs) bb)
 3833               (scan-opnd (jump-opnd gvm-instr)))))
 3834        (else
 3835         (compiler-internal-error
 3836          "bbs-remove-dead-code!, unknown GVM instruction type"))))
 3837    (reachable (lbl-num->bb (bbs-entry-lbl-num bbs) bbs) #f)
 3838    (let loop ()
 3839      (if (not (queue-empty? scan-queue))
 3840          (let ((bb (queue-get! scan-queue)))
 3841            (begin
 3842              (scan-instr (bb-label-instr bb) bb)
 3843              (for-each
 3844               (lambda (gvm-instr) (scan-instr gvm-instr bb))
 3845               (bb-non-branch-instrs bb))
 3846              (scan-instr (bb-branch-instr bb) bb)
 3847              (loop)))))
 3848    (bbs-bb-queue-set! bbs new-bb-queue)))
 3849(define (bbs-remove-useless-jumps! bbs)
 3850  (let ((changed? #f))
 3851    (define (remove-useless-jump bb)
 3852      (let ((branch (bb-branch-instr bb)))
 3853        (if (and (eq? (gvm-instr-type branch) 'jump)
 3854                 (not (first-class-jump? branch))
 3855                 (not (jump-poll? branch))
 3856                 (jump-lbl? branch))
 3857            (let* ((dest-bb (lbl-num->bb (jump-lbl? branch) bbs))
 3858                   (frame1 (gvm-instr-frame (bb-last-non-branch-instr bb)))
 3859                   (frame2 (gvm-instr-frame (bb-label-instr dest-bb))))
 3860              (if (and (eq? (bb-label-type dest-bb) 'simple)
 3861                       (frame-eq? frame1 frame2)
 3862                       (= (length (bb-precedents dest-bb)) 1))
 3863                  (begin
 3864                    (set! changed? #t)
 3865                    (bb-non-branch-instrs-set!
 3866                     bb
 3867                     (append (bb-non-branch-instrs bb)
 3868                             (bb-non-branch-instrs dest-bb)
 3869                             '()))
 3870                    (bb-branch-instr-set! bb (bb-branch-instr dest-bb))
 3871                    (remove-useless-jump bb)))))))
 3872    (for-each remove-useless-jump (queue->list (bbs-bb-queue bbs)))
 3873    changed?))
 3874(define (bbs-remove-common-code! bbs)
 3875  (let* ((bb-list (queue->list (bbs-bb-queue bbs)))
 3876         (n (length bb-list))
 3877         (hash-table-length (cond ((< n 50) 43) ((< n 500) 403) (else 4003)))
 3878         (hash-table (make-vector hash-table-length '()))
 3879         (prim-table '())
 3880         (block-map '())
 3881         (changed? #f))
 3882    (define (hash-prim prim)
 3883      (let ((n (length prim-table)) (i (pos-in-list prim prim-table)))
 3884        (if i
 3885            (- n i)
 3886            (begin (set! prim-table (cons prim prim-table)) (+ n 1)))))
 3887    (define (hash-opnds l)
 3888      (let loop ((l l) (n 0))
 3889        (if (pair? l)
 3890            (loop (cdr l)
 3891                  (let ((x (car l)))
 3892                    (if (lbl? x)
 3893                        n
 3894                        (modulo (+ (* n 10000) x) hash-table-length))))
 3895            n)))
 3896    (define (hash-bb bb)
 3897      (let ((branch (bb-branch-instr bb)))
 3898        (modulo (case (gvm-instr-type branch)
 3899                  ((ifjump)
 3900                   (+ (hash-opnds (ifjump-opnds branch))
 3901                      (* 10 (hash-prim (ifjump-test branch)))
 3902                      (* 100 (frame-size (gvm-instr-frame branch)))))
 3903                  ((jump)
 3904                   (+ (hash-opnds (list (jump-opnd branch)))
 3905                      (* 10 (or (jump-nb-args branch) -1))
 3906                      (* 100 (frame-size (gvm-instr-frame branch)))))
 3907                  (else 0))
 3908                hash-table-length)))
 3909    (define (replacement-lbl-num lbl)
 3910      (let ((x (assv lbl block-map))) (if x (cdr x) lbl)))
 3911    (define (fix-map! bb1 bb2)
 3912      (let loop ((l block-map))
 3913        (if (pair? l)
 3914            (let ((x (car l)))
 3915              (if (= bb1 (cdr x)) (set-cdr! x bb2))
 3916              (loop (cdr l))))))
 3917    (define (enter-bb! bb)
 3918      (let ((h (hash-bb bb)))
 3919        (vector-set! hash-table h (add-bb bb (vector-ref hash-table h)))))
 3920    (define (add-bb bb l)
 3921      (if (pair? l)
 3922          (let ((bb* (car l)))
 3923            (set! block-map
 3924                  (cons (cons (bb-lbl-num bb) (bb-lbl-num bb*)) block-map))
 3925            (if (eqv-bb? bb bb*)
 3926                (begin
 3927                  (fix-map! (bb-lbl-num bb) (bb-lbl-num bb*))
 3928                  (set! changed? #t)
 3929                  l)
 3930                (begin
 3931                  (set! block-map (cdr block-map))
 3932                  (if (eqv-gvm-instr?
 3933                       (bb-branch-instr bb)
 3934                       (bb-branch-instr bb*))
 3935                      (extract-common-tail
 3936                       bb
 3937                       bb*
 3938                       (lambda (head head* tail)
 3939                         (if (null? tail)
 3940                             (cons bb* (add-bb bb (cdr l)))
 3941                             (let* ((lbl (bbs-new-lbl! bbs))
 3942                                    (branch (bb-branch-instr bb))
 3943                                    (fs** (need-gvm-instrs tail branch))
 3944                                    (frame (frame-truncate
 3945                                            (gvm-instr-frame
 3946                                             (if (null? head)
 3947                                                 (bb-label-instr bb)
 3948                                                 (car head)))
 3949                                            fs**))
 3950                                    (bb** (make-bb (make-label-simple
 3951                                                    lbl
 3952                                                    frame
 3953                                                    #f)
 3954                                                   bbs)))
 3955                               (bb-non-branch-instrs-set! bb** tail)
 3956                               (bb-branch-instr-set! bb** branch)
 3957                               (bb-non-branch-instrs-set! bb* (reverse head*))
 3958                               (bb-branch-instr-set!
 3959                                bb*
 3960                                (make-jump (make-lbl lbl) #f #f frame #f))
 3961                               (bb-non-branch-instrs-set! bb (reverse head))
 3962                               (bb-branch-instr-set!
 3963                                bb
 3964                                (make-jump (make-lbl lbl) #f #f frame #f))
 3965                               (set! changed? #t)
 3966                               (cons bb (cons bb* (add-bb bb** (cdr l))))))))
 3967                      (cons bb* (add-bb bb (cdr l)))))))
 3968          (list bb)))
 3969    (define (extract-common-tail bb1 bb2 cont)
 3970      (let loop ((l1 (reverse (bb-non-branch-instrs bb1)))
 3971                 (l2 (reverse (bb-non-branch-instrs bb2)))
 3972                 (tail '()))
 3973        (if (and (pair? l1) (pair? l2))
 3974            (let ((i1 (car l1)) (i2 (car l2)))
 3975              (if (eqv-gvm-instr? i1 i2)
 3976                  (loop (cdr l1) (cdr l2) (cons i1 tail))
 3977                  (cont l1 l2 tail)))
 3978            (cont l1 l2 tail))))
 3979    (define (eqv-bb? bb1 bb2)
 3980      (let ((bb1-non-branch (bb-non-branch-instrs bb1))
 3981            (bb2-non-branch (bb-non-branch-instrs bb2)))
 3982        (and (= (length bb1-non-branch) (length bb2-non-branch))
 3983             (eqv-gvm-instr? (bb-label-instr bb1) (bb-label-instr bb2))
 3984             (eqv-gvm-instr? (bb-branch-instr bb1) (bb-branch-instr bb2))
 3985             (eqv-list? eqv-gvm-instr? bb1-non-branch bb2-non-branch))))
 3986    (define (eqv-list? pred? l1 l2)
 3987      (if (pair? l1)
 3988          (and (pair? l2)
 3989               (pred? (car l1) (car l2))
 3990               (eqv-list? pred? (cdr l1) (cdr l2)))
 3991          (not (pair? l2))))
 3992    (define (eqv-lbl-num? lbl1 lbl2)
 3993      (= (replacement-lbl-num lbl1) (replacement-lbl-num lbl2)))
 3994    (define (eqv-gvm-opnd? opnd1 opnd2)
 3995      (if (not opnd1)
 3996          (not opnd2)
 3997          (and opnd2
 3998               (cond ((lbl? opnd1)
 3999                      (and (lbl? opnd2)
 4000                           (eqv-lbl-num? (lbl-num opnd1) (lbl-num opnd2))))
 4001                     ((clo? opnd1)
 4002                      (and (clo? opnd2)
 4003                           (= (clo-index opnd1) (clo-index opnd2))
 4004                           (eqv-gvm-opnd? (clo-base opnd1) (clo-base opnd2))))
 4005                     (else (eqv? opnd1 opnd2))))))
 4006    (define (eqv-gvm-instr? instr1 instr2)
 4007      (define (eqv-closure-parms? p1 p2)
 4008        (and (eqv-gvm-opnd? (closure-parms-loc p1) (closure-parms-loc p2))
 4009             (eqv-lbl-num? (closure-parms-lbl p1) (closure-parms-lbl p2))
 4010             (eqv-list?
 4011              eqv-gvm-opnd?
 4012              (closure-parms-opnds p1)
 4013              (closure-parms-opnds p2))))
 4014      (let ((type1 (gvm-instr-type instr1)) (type2 (gvm-instr-type instr2)))
 4015        (and (eq? type1 type2)
 4016             (frame-eq? (gvm-instr-frame instr1) (gvm-instr-frame instr2))
 4017             (case type1
 4018               ((label)
 4019                (let ((ltype1 (label-type instr1))
 4020                      (ltype2 (label-type instr2)))
 4021                  (and (eq? ltype1 ltype2)
 4022                       (case ltype1
 4023                         ((simple return task-entry task-return) #t)
 4024                         ((entry)
 4025                          (and (= (label-entry-min instr1)
 4026                                  (label-entry-min instr2))
 4027                               (= (label-entry-nb-parms instr1)
 4028                                  (label-entry-nb-parms instr2))
 4029                               (eq? (label-entry-rest? instr1)
 4030                                    (label-entry-rest? instr2))
 4031                               (eq? (label-entry-closed? instr1)
 4032                                    (label-entry-closed? instr2))))
 4033                         (else
 4034                          (compiler-internal-error
 4035                           "eqv-gvm-instr?, unknown label type"))))))
 4036               ((apply)
 4037                (and (eq? (apply-prim instr1) (apply-prim instr2))
 4038                     (eqv-list?
 4039                      eqv-gvm-opnd?
 4040                      (apply-opnds instr1)
 4041                      (apply-opnds instr2))
 4042                     (eqv-gvm-opnd? (apply-loc instr1) (apply-loc instr2))))
 4043               ((copy)
 4044                (and (eqv-gvm-opnd? (copy-opnd instr1) (copy-opnd instr2))
 4045                     (eqv-gvm-opnd? (copy-loc instr1) (copy-loc instr2))))
 4046               ((close)
 4047                (eqv-list?
 4048                 eqv-closure-parms?
 4049                 (close-parms instr1)
 4050                 (close-parms instr2)))
 4051               ((ifjump)
 4052                (and (eq? (ifjump-test instr1) (ifjump-test instr2))
 4053                     (eqv-list?
 4054                      eqv-gvm-opnd?
 4055                      (ifjump-opnds instr1)
 4056                      (ifjump-opnds instr2))
 4057                     (eqv-lbl-num? (ifjump-true instr1) (ifjump-true instr2))
 4058                     (eqv-lbl-num? (ifjump-false instr1) (ifjump-false instr2))
 4059                     (eq? (ifjump-poll? instr1) (ifjump-poll? instr2))))
 4060               ((jump)
 4061                (and (eqv-gvm-opnd? (jump-opnd instr1) (jump-opnd instr2))
 4062                     (eqv? (jump-nb-args instr1) (jump-nb-args instr2))
 4063                     (eq? (jump-poll? instr1) (jump-poll? instr2))))
 4064               (else
 4065                (compiler-internal-error
 4066                 "eqv-gvm-instr?, unknown 'gvm-instr':"
 4067                 instr1))))))
 4068    (define (update-bb! bb) (replace-label-references! bb replacement-lbl-num))
 4069    (for-each enter-bb! bb-list)
 4070    (bbs-entry-lbl-num-set! bbs (replacement-lbl-num (bbs-entry-lbl-num bbs)))
 4071    (let loop ((i 0) (result '()))
 4072      (if (< i hash-table-length)
 4073          (let ((bb-kept (vector-ref hash-table i)))
 4074            (for-each update-bb! bb-kept)
 4075            (loop (+ i 1) (append bb-kept result)))
 4076          (bbs-bb-queue-set! bbs (list->queue result))))
 4077    changed?))
 4078(define (replace-label-references! bb replacement-lbl-num)
 4079  (define (update-gvm-opnd opnd)
 4080    (if opnd
 4081        (cond ((lbl? opnd) (make-lbl (replacement-lbl-num (lbl-num opnd))))
 4082              ((clo? opnd)
 4083               (make-clo (update-gvm-opnd (clo-base opnd)) (clo-index opnd)))
 4084              (else opnd))
 4085        opnd))
 4086  (define (update-gvm-instr instr)
 4087    (define (update-closure-parms p)
 4088      (make-closure-parms
 4089       (update-gvm-opnd (closure-parms-loc p))
 4090       (replacement-lbl-num (closure-parms-lbl p))
 4091       (map update-gvm-opnd (closure-parms-opnds p))))
 4092    (case (gvm-instr-type instr)
 4093      ((apply)
 4094       (make-apply
 4095        (apply-prim instr)
 4096        (map update-gvm-opnd (apply-opnds instr))
 4097        (update-gvm-opnd (apply-loc instr))
 4098        (gvm-instr-frame instr)
 4099        (gvm-instr-comment instr)))
 4100      ((copy)
 4101       (make-copy
 4102        (update-gvm-opnd (copy-opnd instr))
 4103        (update-gvm-opnd (copy-loc instr))
 4104        (gvm-instr-frame instr)
 4105        (gvm-instr-comment instr)))
 4106      ((close)
 4107       (make-close
 4108        (map update-closure-parms (close-parms instr))
 4109        (gvm-instr-frame instr)
 4110        (gvm-instr-comment instr)))
 4111      ((ifjump)
 4112       (make-ifjump
 4113        (ifjump-test instr)
 4114        (map update-gvm-opnd (ifjump-opnds instr))
 4115        (replacement-lbl-num (ifjump-true instr))
 4116        (replacement-lbl-num (ifjump-false instr))
 4117        (ifjump-poll? instr)
 4118        (gvm-instr-frame instr)
 4119        (gvm-instr-comment instr)))
 4120      ((jump)
 4121       (make-jump
 4122        (update-gvm-opnd (jump-opnd instr))
 4123        (jump-nb-args instr)
 4124        (jump-poll? instr)
 4125        (gvm-instr-frame instr)
 4126        (gvm-instr-comment instr)))
 4127      (else
 4128       (compiler-internal-error "update-gvm-instr, unknown 'instr':" instr))))
 4129  (bb-non-branch-instrs-set!
 4130   bb
 4131   (map update-gvm-instr (bb-non-branch-instrs bb)))
 4132  (bb-branch-instr-set! bb (update-gvm-instr (bb-branch-instr bb))))
 4133(define (bbs-order! bbs)
 4134  (let ((new-bb-queue (queue-empty))
 4135        (left-to-schedule (queue->list (bbs-bb-queue bbs))))
 4136    (define (remove x l)
 4137      (if (eq? (car l) x) (cdr l) (cons (car l) (remove x (cdr l)))))
 4138    (define (remove-bb! bb)
 4139      (set! left-to-schedule (remove bb left-to-schedule))
 4140      bb)
 4141    (define (prec-bb bb)
 4142      (let loop ((l (bb-precedents bb)) (best #f) (best-fs #f))
 4143        (if (null? l)
 4144            best
 4145            (let* ((x (car l)) (x-fs (bb-exit-frame-size x)))
 4146              (if (and (memq x left-to-schedule)
 4147                       (or (not best) (< x-fs best-fs)))
 4148                  (loop (cdr l) x x-fs)
 4149                  (loop (cdr l) best best-fs))))))
 4150    (define (succ-bb bb)
 4151      (define (branches-to-lbl? bb)
 4152        (let ((branch (bb-branch-instr bb)))
 4153          (case (gvm-instr-type branch)
 4154            ((ifjump) #t)
 4155            ((jump) (lbl? (jump-opnd branch)))
 4156            (else
 4157             (compiler-internal-error "bbs-order!, unknown branch type")))))
 4158      (define (best-succ bb1 bb2)
 4159        (if (branches-to-lbl? bb1)
 4160            bb1
 4161            (if (branches-to-lbl? bb2)
 4162                bb2
 4163                (if (< (bb-exit-frame-size bb1) (bb-exit-frame-size bb2))
 4164                    bb2
 4165                    bb1))))
 4166      (let ((branch (bb-branch-instr bb)))
 4167        (case (gvm-instr-type branch)
 4168          ((ifjump)
 4169           (let* ((true-bb (lbl-num->bb (ifjump-true branch) bbs))
 4170                  (true-bb* (and (memq true-bb left-to-schedule) true-bb))
 4171                  (false-bb (lbl-num->bb (ifjump-false branch) bbs))
 4172                  (false-bb* (and (memq false-bb left-to-schedule) false-bb)))
 4173             (if (and true-bb* false-bb*)
 4174                 (best-succ true-bb* false-bb*)
 4175                 (or true-bb* false-bb*))))
 4176          ((jump)
 4177           (let ((opnd (jump-opnd branch)))
 4178             (and (lbl? opnd)
 4179                  (let ((bb (lbl-num->bb (lbl-num opnd) bbs)))
 4180                    (and (memq bb left-to-schedule) bb)))))
 4181          (else (compiler-internal-error "bbs-order!, unknown branch type")))))
 4182    (define (schedule-from bb)
 4183      (queue-put! new-bb-queue bb)
 4184      (let ((x (succ-bb bb)))
 4185        (if x
 4186            (begin
 4187              (schedule-around (remove-bb! x))
 4188              (let ((y (succ-bb bb)))
 4189                (if y (schedule-around (remove-bb! y)))))))
 4190      (schedule-refs bb))
 4191    (define (schedule-around bb)
 4192      (let ((x (prec-bb bb)))
 4193        (if x
 4194            (let ((bb-list (schedule-back (remove-bb! x) '())))
 4195              (queue-put! new-bb-queue x)
 4196              (schedule-forw bb)
 4197              (for-each schedule-refs bb-list))
 4198            (schedule-from bb))))
 4199    (define (schedule-back bb bb-list)
 4200      (let ((bb-list* (cons bb bb-list)) (x (prec-bb bb)))
 4201        (if x
 4202            (let ((bb-list (schedule-back (remove-bb! x) bb-list*)))
 4203              (queue-put! new-bb-queue x)
 4204              bb-list)
 4205            bb-list*)))
 4206    (define (schedule-forw bb)
 4207      (queue-put! new-bb-queue bb)
 4208      (let ((x (succ-bb bb)))
 4209        (if x
 4210            (begin
 4211              (schedule-forw (remove-bb! x))
 4212              (let ((y (succ-bb bb)))
 4213                (if y (schedule-around (remove-bb! y)))))))
 4214      (schedule-refs bb))
 4215    (define (schedule-refs bb)
 4216      (for-each
 4217       (lambda (x)
 4218         (if (memq x left-to-schedule) (schedule-around (remove-bb! x))))
 4219       (bb-references bb)))
 4220    (schedule-from (remove-bb! (lbl-num->bb (bbs-entry-lbl-num bbs) bbs)))
 4221    (bbs-bb-queue-set! bbs new-bb-queue)
 4222    (let ((bb-list (queue->list new-bb-queue)))
 4223      (let loop ((l bb-list) (i 1) (lbl-map '()))
 4224        (if (pair? l)
 4225            (let* ((label-instr (bb-label-instr (car l)))
 4226                   (old-lbl-num (label-lbl-num label-instr)))
 4227              (label-lbl-num-set! label-instr i)
 4228              (loop (cdr l) (+ i 1) (cons (cons old-lbl-num i) lbl-map)))
 4229            (let ()
 4230              (define (replacement-lbl-num x) (cdr (assv x lbl-map)))
 4231              (define (update-bb! bb)
 4232                (replace-label-references! bb replacement-lbl-num))
 4233              (for-each update-bb! bb-list)
 4234              (bbs-lbl-counter-set!
 4235               bbs
 4236               (make-counter
 4237                (* (+ 1 (quotient (bbs-new-lbl! bbs) 1000)) 1000)
 4238                label-limit
 4239                bbs-limit-err))))))))
 4240(define (make-code bb gvm-instr sn) (vector bb gvm-instr sn))
 4241(define (code-bb code) (vector-ref code 0))
 4242(define (code-gvm-instr code) (vector-ref code 1))
 4243(define (code-slots-needed code) (vector-ref code 2))
 4244(define (code-slots-needed-set! code n) (vector-set! code 2 n))
 4245(define (bbs->code-list bbs)
 4246  (let ((code-list (linearize bbs)))
 4247    (setup-slots-needed! code-list)
 4248    code-list))
 4249(define (linearize bbs)
 4250  (let ((code-queue (queue-empty)))
 4251    (define (put-bb bb)
 4252      (define (put-instr gvm-instr)
 4253        (queue-put! code-queue (make-code bb gvm-instr #f)))
 4254      (put-instr (bb-label-instr bb))
 4255      (for-each put-instr (bb-non-branch-instrs bb))
 4256      (put-instr (bb-branch-instr bb)))
 4257    (for-each put-bb (queue->list (bbs-bb-queue bbs)))
 4258    (queue->list code-queue)))
 4259(define (setup-slots-needed! code-list)
 4260  (if (null? code-list)
 4261      #f
 4262      (let* ((code (car code-list))
 4263             (gvm-instr (code-gvm-instr code))
 4264             (sn-rest (setup-slots-needed! (cdr code-list))))
 4265        (case (gvm-instr-type gvm-instr)
 4266          ((label)
 4267           (if (> sn-rest (frame-size (gvm-instr-frame gvm-instr)))
 4268               (compiler-internal-error
 4269                "setup-slots-needed!, incoherent slots needed for LABEL"))
 4270           (code-slots-needed-set! code sn-rest)
 4271           #f)
 4272          ((ifjump jump)
 4273           (let ((sn (frame-size (gvm-instr-frame gvm-instr))))
 4274             (code-slots-needed-set! code sn)
 4275             (need-gvm-instr gvm-instr sn)))
 4276          (else
 4277           (code-slots-needed-set! code sn-rest)
 4278           (need-gvm-instr gvm-instr sn-rest))))))
 4279(define (need-gvm-instrs non-branch branch)
 4280  (if (pair? non-branch)
 4281      (need-gvm-instr
 4282       (car non-branch)
 4283       (need-gvm-instrs (cdr non-branch) branch))
 4284      (need-gvm-instr branch (frame-size (gvm-instr-frame branch)))))
 4285(define (need-gvm-instr gvm-instr sn-rest)
 4286  (case (gvm-instr-type gvm-instr)
 4287    ((label) sn-rest)
 4288    ((apply)
 4289     (let ((loc (apply-loc gvm-instr)))
 4290       (need-gvm-opnds
 4291        (apply-opnds gvm-instr)
 4292        (need-gvm-loc-opnd loc (need-gvm-loc loc sn-rest)))))
 4293    ((copy)
 4294     (let ((loc (copy-loc gvm-instr)))
 4295       (need-gvm-opnd
 4296        (copy-opnd gvm-instr)
 4297        (need-gvm-loc-opnd loc (need-gvm-loc loc sn-rest)))))
 4298    ((close)
 4299     (let ((parms (close-parms gvm-instr)))
 4300       (define (need-parms-opnds p)
 4301         (if (null? p)
 4302             sn-rest
 4303             (need-gvm-opnds
 4304              (closure-parms-opnds (car p))
 4305              (need-parms-opnds (cdr p)))))
 4306       (define (need-parms-loc p)
 4307         (if (null? p)
 4308             (need-parms-opnds parms)
 4309             (let ((loc (closure-parms-loc (car p))))
 4310               (need-gvm-loc-opnd
 4311                loc
 4312                (need-gvm-loc loc (need-parms-loc (cdr p)))))))
 4313       (need-parms-loc parms)))
 4314    ((ifjump) (need-gvm-opnds (ifjump-opnds gvm-instr) sn-rest))
 4315    ((jump) (need-gvm-opnd (jump-opnd gvm-instr) sn-rest))
 4316    (else
 4317     (compiler-internal-error
 4318      "need-gvm-instr, unknown 'gvm-instr':"
 4319      gvm-instr))))
 4320(define (need-gvm-loc loc sn-rest)
 4321  (if (and loc (stk? loc) (>= (stk-num loc) sn-rest))
 4322      (- (stk-num loc) 1)
 4323      sn-rest))
 4324(define (need-gvm-loc-opnd gvm-loc slots-needed)
 4325  (if (and gvm-loc (clo? gvm-loc))
 4326      (need-gvm-opnd (clo-base gvm-loc) slots-needed)
 4327      slots-needed))
 4328(define (need-gvm-opnd gvm-opnd slots-needed)
 4329  (cond ((stk? gvm-opnd) (max (stk-num gvm-opnd) slots-needed))
 4330        ((clo? gvm-opnd) (need-gvm-opnd (clo-base gvm-opnd) slots-needed))
 4331        (else slots-needed)))
 4332(define (need-gvm-opnds gvm-opnds slots-needed)
 4333  (if (null? gvm-opnds)
 4334      slots-needed
 4335      (need-gvm-opnd
 4336       (car gvm-opnds)
 4337       (need-gvm-opnds (cdr gvm-opnds) slots-needed))))
 4338(define (write-bb bb port)
 4339  (write-gvm-instr (bb-label-instr bb) port)
 4340  (display " [precedents=" port)
 4341  (write (map bb-lbl-num (bb-precedents bb)) port)
 4342  (display "]" port)
 4343  (newline port)
 4344  (for-each
 4345   (lambda (x) (write-gvm-instr x port) (newline port))
 4346   (bb-non-branch-instrs bb))
 4347  (write-gvm-instr (bb-branch-instr bb) port))
 4348(define (write-bbs bbs port)
 4349  (for-each
 4350   (lambda (bb)
 4351     (if (= (bb-lbl-num bb) (bbs-entry-lbl-num bbs))
 4352         (begin (display "**** Entry block:" port) (newline port)))
 4353     (write-bb bb port)
 4354     (newline port))
 4355   (queue->list (bbs-bb-queue bbs))))
 4356(define (virtual.dump proc port)
 4357  (let ((proc-seen (queue-empty)) (proc-left (queue-empty)))
 4358    (define (scan-opnd gvm-opnd)
 4359      (cond ((obj? gvm-opnd)
 4360             (let ((val (obj-val gvm-opnd)))
 4361               (if (and (proc-obj? val)
 4362                        (proc-obj-code val)
 4363                        (not (memq val (queue->list proc-seen))))
 4364                   (begin
 4365                     (queue-put! proc-seen val)
 4366                     (queue-put! proc-left val)))))
 4367            ((clo? gvm-opnd) (scan-opnd (clo-base gvm-opnd)))))
 4368    (define (dump-proc p)
 4369      (define (scan-code code)
 4370        (let ((gvm-instr (code-gvm-instr code)))
 4371          (write-gvm-instr gvm-instr port)
 4372          (newline port)
 4373          (case (gvm-instr-type gvm-instr)
 4374            ((apply)
 4375             (for-each scan-opnd (apply-opnds gvm-instr))
 4376             (if (apply-loc gvm-instr) (scan-opnd (apply-loc gvm-instr))))
 4377            ((copy)
 4378             (scan-opnd (copy-opnd gvm-instr))
 4379             (scan-opnd (copy-loc gvm-instr)))
 4380            ((close)
 4381             (for-each
 4382              (lambda (parms)
 4383                (scan-opnd (closure-parms-loc parms))
 4384                (for-each scan-opnd (closure-parms-opnds parms)))
 4385              (close-parms gvm-instr)))
 4386            ((ifjump) (for-each scan-opnd (ifjump-opnds gvm-instr)))
 4387            ((jump) (scan-opnd (jump-opnd gvm-instr)))
 4388            (else '()))))
 4389      (if (proc-obj-primitive? p)
 4390          (display "**** #[primitive " port)
 4391          (display "**** #[procedure " port))
 4392      (display (proc-obj-name p) port)
 4393      (display "] =" port)
 4394      (newline port)
 4395      (let loop ((l (bbs->code-list (proc-obj-code p)))
 4396                 (prev-filename "")
 4397                 (prev-line 0))
 4398        (if (pair? l)
 4399            (let* ((code (car l))
 4400                   (instr (code-gvm-instr code))
 4401                   (src (comment-get (gvm-instr-comment instr) 'source))
 4402                   (loc (and src (source-locat src)))
 4403                   (filename
 4404                    (if (and loc (eq? (vector-ref loc 0) 'file))
 4405                        (vector-ref loc 1)
 4406                        prev-filename))
 4407                   (line (if (and loc (eq? (vector-ref loc 0) 'file))
 4408                             (vector-ref loc 3)
 4409                             prev-line)))
 4410              (if (or (not (string=? filename prev-filename))
 4411                      (not (= line prev-line)))
 4412                  (begin
 4413                    (display "#line " port)
 4414                    (display line port)
 4415                    (if (not (string=? filename prev-filename))
 4416                        (begin (display " " port) (write filename port)))
 4417                    (newline port)))
 4418              (scan-code code)
 4419              (loop (cdr l) filename line))
 4420            (newline port))))
 4421    (scan-opnd (make-obj proc))
 4422    (let loop ()
 4423      (if (not (queue-empty? proc-left))
 4424          (begin (dump-proc (queue-get! proc-left)) (loop))))))
 4425(define (write-gvm-instr gvm-instr port)
 4426  (define (write-closure-parms parms)
 4427    (display " " port)
 4428    (let ((len (+ 1 (write-gvm-opnd (closure-parms-loc parms) port))))
 4429      (display " = (" port)
 4430      (let ((len (+ len (+ 4 (write-gvm-lbl (closure-parms-lbl parms) port)))))
 4431        (+ len
 4432           (write-terminated-opnd-list (closure-parms-opnds parms) port)))))
 4433  (define (write-terminated-opnd-list l port)
 4434    (let loop ((l l) (len 0))
 4435      (if (pair? l)
 4436          (let ((opnd (car l)))
 4437            (display " " port)
 4438            (loop (cdr l) (+ len (+ 1 (write-gvm-opnd opnd port)))))
 4439          (begin (display ")" port) (+ len 1)))))
 4440  (define (write-param-pattern gvm-instr port)
 4441    (let ((len (if (not (= (label-entry-min gvm-instr)
 4442                           (label-entry-nb-parms gvm-instr)))
 4443                   (let ((len (write-returning-len
 4444                               (label-entry-min gvm-instr)
 4445                               port)))
 4446                     (display "-" port)
 4447                     (+ len 1))
 4448                   0)))
 4449      (let ((len (+ len
 4450                    (write-returning-len
 4451                     (label-entry-nb-parms gvm-instr)
 4452                     port))))
 4453        (if (label-entry-rest? gvm-instr)
 4454            (begin (display "+" port) (+ len 1))
 4455            len))))
 4456  (define (write-prim-applic prim opnds port)
 4457    (display "(" port)
 4458    (let ((len (+ 1 (display-returning-len (proc-obj-name prim) port))))
 4459      (+ len (write-terminated-opnd-list opnds port))))
 4460  (define (write-instr gvm-instr)
 4461    (case (gvm-instr-type gvm-instr)
 4462      ((label)
 4463       (let ((len (write-gvm-lbl (label-lbl-num gvm-instr) port)))
 4464         (display " " port)
 4465         (let ((len (+ len
 4466                       (+ 1
 4467                          (write-returning-len
 4468                           (frame-size (gvm-instr-frame gvm-instr))
 4469                           port)))))
 4470           (case (label-type gvm-instr)
 4471             ((simple) len)
 4472             ((entry)
 4473              (if (label-entry-closed? gvm-instr)
 4474                  (begin
 4475                    (display " closure-entry-point " port)
 4476                    (+ len (+ 21 (write-param-pattern gvm-instr port))))
 4477                  (begin
 4478                    (display " entry-point " port)
 4479                    (+ len (+ 13 (write-param-pattern gvm-instr port))))))
 4480             ((return) (display " return-point" port) (+ len 13))
 4481             ((task-entry) (display " task-entry-point" port) (+ len 17))
 4482             ((task-return) (display " task-return-point" port) (+ len 18))
 4483             (else
 4484              (compiler-internal-error
 4485               "write-gvm-instr, unknown label type"))))))
 4486      ((apply)
 4487       (display "  " port)
 4488       (let ((len (+ 2
 4489                     (if (apply-loc gvm-instr)
 4490                         (let ((len (write-gvm-opnd
 4491                                     (apply-loc gvm-instr)
 4492                                     port)))
 4493                           (display " = " port)
 4494                           (+ len 3))
 4495                         0))))
 4496         (+ len
 4497            (write-prim-applic
 4498             (apply-prim gvm-instr)
 4499             (apply-opnds gvm-instr)
 4500             port))))
 4501      ((copy)
 4502       (display "  " port)
 4503       (let ((len (+ 2 (write-gvm-opnd (copy-loc gvm-instr) port))))
 4504         (display " = " port)
 4505         (+ len (+ 3 (write-gvm-opnd (copy-opnd gvm-instr) port)))))
 4506      ((close)
 4507       (display "  close" port)
 4508       (let ((len (+ 7 (write-closure-parms (car (close-parms gvm-instr))))))
 4509         (let loop ((l (cdr (close-parms gvm-instr))) (len len))
 4510           (if (pair? l)
 4511               (let ((x (car l)))
 4512                 (display "," port)
 4513                 (loop (cdr l) (+ len (+ 1 (write-closure-parms x)))))
 4514               len))))
 4515      ((ifjump)
 4516       (display "  if " port)
 4517       (let ((len (+ 5
 4518                     (write-prim-applic
 4519                      (ifjump-test gvm-instr)
 4520                      (ifjump-opnds gvm-instr)
 4521                      port))))
 4522         (let ((len (+ len
 4523                       (if (ifjump-poll? gvm-instr)
 4524                           (begin (display " jump* " port) 7)
 4525                           (begin (display " jump " port) 6)))))
 4526           (let ((len (+ len
 4527                         (write-returning-len
 4528                          (frame-size (gvm-instr-frame gvm-instr))
 4529                          port))))
 4530             (display " " port)
 4531             (let ((len (+ len
 4532                           (+ 1
 4533                              (write-gvm-lbl (ifjump-true gvm-instr) port)))))
 4534               (display " else " port)
 4535               (+ len (+ 6 (write-gvm-lbl (ifjump-false gvm-instr) port))))))))
 4536      ((jump)
 4537       (display "  " port)
 4538       (let ((len (+ 2
 4539                     (if (jump-poll? gvm-instr)
 4540                         (begin (display "jump* " port) 6)
 4541                         (begin (display "jump " port) 5)))))
 4542         (let ((len (+ len
 4543                       (write-returning-len
 4544                        (frame-size (gvm-instr-frame gvm-instr))
 4545                        port))))
 4546           (display " " port)
 4547           (let ((len (+ len
 4548                         (+ 1 (write-gvm-opnd (jump-opnd gvm-instr) port)))))
 4549             (+ len
 4550                (if (jump-nb-args gvm-instr)
 4551                    (begin
 4552                      (display " " port)
 4553                      (+ 1
 4554                         (write-returning-len (jump-nb-args gvm-instr) port)))
 4555                    0))))))
 4556      (else
 4557       (compiler-internal-error
 4558        "write-gvm-instr, unknown 'gvm-instr':"
 4559        gvm-instr))))
 4560  (define (spaces n)
 4561    (if (> n 0)
 4562        (if (> n 7)
 4563            (begin (display "        " port) (spaces (- n 8)))
 4564            (begin (display " " port) (spaces (- n 1))))))
 4565  (let ((len (write-instr gvm-instr)))
 4566    (spaces (- 40 len))
 4567    (display " " port)
 4568    (write-frame (gvm-instr-frame gvm-instr) port))
 4569  (let ((x (gvm-instr-comment gvm-instr)))
 4570    (if x
 4571        (let ((y (comment-get x 'text)))
 4572          (if y (begin (display " ; " port) (display y port)))))))
 4573(define (write-frame frame port)
 4574  (define (write-var var opnd sep)
 4575    (display sep port)
 4576    (write-gvm-opnd opnd port)
 4577    (if var
 4578        (begin
 4579          (display "=" port)
 4580          (cond ((eq? var closure-env-var)
 4581                 (write (map (lambda (var) (var-name var))
 4582                             (frame-closed frame))
 4583                        port))
 4584                ((eq? var ret-var) (display "#" port))
 4585                ((temp-var? var) (display "." port))
 4586                (else (write (var-name var) port))))))
 4587  (define (live? var)
 4588    (let ((live (frame-live frame)))
 4589      (or (set-member? var live)
 4590          (and (eq? var closure-env-var)
 4591               (not (set-empty?
 4592                     (set-intersection
 4593                      live
 4594                      (list->set (frame-closed frame)))))))))
 4595  (let loop1 ((i 1) (l (reverse (frame-slots frame))) (sep "; "))
 4596    (if (pair? l)
 4597        (let ((var (car l)))
 4598          (write-var (if (live? var) var #f) (make-stk i) sep)
 4599          (loop1 (+ i 1) (cdr l) " "))
 4600        (let loop2 ((i 0) (l (frame-regs frame)) (sep sep))
 4601          (if (pair? l)
 4602              (let ((var (car l)))
 4603                (if (live? var)
 4604                    (begin
 4605                      (write-var var (make-reg i) sep)
 4606                      (loop2 (+ i 1) (cdr l) " "))
 4607                    (loop2 (+ i 1) (cdr l) sep))))))))
 4608(define (write-gvm-opnd gvm-opnd port)
 4609  (define (write-opnd)
 4610    (cond ((reg? gvm-opnd)
 4611           (display "+" port)
 4612           (+ 1 (write-returning-len (reg-num gvm-opnd) port)))
 4613          ((stk? gvm-opnd)
 4614           (display "-" port)
 4615           (+ 1 (write-returning-len (stk-num gvm-opnd) port)))
 4616          ((glo? gvm-opnd) (write-returning-len (glo-name gvm-opnd) port))
 4617          ((clo? gvm-opnd)
 4618           (let ((len (write-gvm-opnd (clo-base gvm-opnd) port)))
 4619             (display "(" port)
 4620             (let ((len (+ len
 4621                           (+ 1
 4622                              (write-returning-len
 4623                               (clo-index gvm-opnd)
 4624                               port)))))
 4625               (display ")" port)
 4626               (+ len 1))))
 4627          ((lbl? gvm-opnd) (write-gvm-lbl (lbl-num gvm-opnd) port))
 4628          ((obj? gvm-opnd)
 4629           (display "'" port)
 4630           (+ (write-gvm-obj (obj-val gvm-opnd) port) 1))
 4631          (else
 4632           (compiler-internal-error
 4633            "write-gvm-opnd, unknown 'gvm-opnd':"
 4634            gvm-opnd))))
 4635  (write-opnd))
 4636(define (write-gvm-lbl lbl port)
 4637  (display "#" port)
 4638  (+ (write-returning-len lbl port) 1))
 4639(define (write-gvm-obj val port)
 4640  (cond ((false-object? val) (display "#f" port) 2)
 4641        ((undef-object? val) (display "#[undefined]" port) 12)
 4642        ((proc-obj? val)
 4643         (if (proc-obj-primitive? val)
 4644             (display "#[primitive " port)
 4645             (display "#[procedure " port))
 4646         (let ((len (display-returning-len (proc-obj-name val) port)))
 4647           (display "]" port)
 4648           (+ len 13)))
 4649        (else (write-returning-len val port))))
 4650(define (virtual.begin!)
 4651  (set! *opnd-table* (make-vector opnd-table-size))
 4652  (set! *opnd-table-alloc* 0)
 4653  '())
 4654(define (virtual.end!) (set! *opnd-table* '()) '())
 4655(define (make-target version name)
 4656  (define current-target-version 4)
 4657  (if (not (= version current-target-version))
 4658      (compiler-internal-error
 4659       "make-target, version of target package is not current"
 4660       name))
 4661  (let ((x (make-vector 11))) (vector-set! x 1 name) x))
 4662(define (target-name x) (vector-ref x 1))
 4663(define (target-begin! x) (vector-ref x 2))
 4664(define (target-begin!-set! x y) (vector-set! x 2 y))
 4665(define (target-end! x) (vector-ref x 3))
 4666(define (target-end!-set! x y) (vector-set! x 3 y))
 4667(define (target-dump x) (vector-ref x 4))
 4668(define (target-dump-set! x y) (vector-set! x 4 y))
 4669(define (target-nb-regs x) (vector-ref x 5))
 4670(define (target-nb-regs-set! x y) (vector-set! x 5 y))
 4671(define (target-prim-info x) (vector-ref x 6))
 4672(define (target-prim-info-set! x y) (vector-set! x 6 y))
 4673(define (target-label-info x) (vector-ref x 7))
 4674(define (target-label-info-set! x y) (vector-set! x 7 y))
 4675(define (target-jump-info x) (vector-ref x 8))
 4676(define (target-jump-info-set! x y) (vector-set! x 8 y))
 4677(define (target-proc-result x) (vector-ref x 9))
 4678(define (target-proc-result-set! x y) (vector-set! x 9 y))
 4679(define (target-task-return x) (vector-ref x 10))
 4680(define (target-task-return-set! x y) (vector-set! x 10 y))
 4681(define targets-loaded '())
 4682(define (get-target name)
 4683  (let ((x (assq name targets-loaded)))
 4684    (if x (cdr x) (compiler-error "Target package is not available" name))))
 4685(define (put-target targ)
 4686  (let* ((name (target-name targ)) (x (assq name targets-loaded)))
 4687    (if x
 4688        (set-cdr! x targ)
 4689        (set! targets-loaded (cons (cons name targ) targets-loaded)))
 4690    '()))
 4691(define (default-target)
 4692  (if (null? targets-loaded)
 4693      (compiler-error "No target package is available")
 4694      (car (car targets-loaded))))
 4695(define (select-target! name info-port)
 4696  (set! target (get-target name))
 4697  ((target-begin! target) info-port)
 4698  (set! target.dump (target-dump target))
 4699  (set! target.nb-regs (target-nb-regs target))
 4700  (set! target.prim-info (target-prim-info target))
 4701  (set! target.label-info (target-label-info target))
 4702  (set! target.jump-info (target-jump-info target))
 4703  (set! target.proc-result (target-proc-result target))
 4704  (set! target.task-return (target-task-return target))
 4705  (set! **not-proc-obj (target.prim-info **not-sym))
 4706  '())
 4707(define (unselect-target!) ((target-end! target)) '())
 4708(define target '())
 4709(define target.dump '())
 4710(define target.nb-regs '())
 4711(define target.prim-info '())
 4712(define target.label-info '())
 4713(define target.jump-info '())
 4714(define target.proc-result '())
 4715(define target.task-return '())
 4716(define **not-proc-obj '())
 4717(define (target.specialized-prim-info* name decl)
 4718  (let ((x (target.prim-info* name decl)))
 4719    (and x ((proc-obj-specialize x) decl))))
 4720(define (target.prim-info* name decl)
 4721  (and (if (standard-procedure name decl)
 4722           (standard-binding? name decl)
 4723           (extended-binding? name decl))
 4724       (target.prim-info name)))
 4725(define generic-sym (string->canonical-symbol "GENERIC"))
 4726(define fixnum-sym (string->canonical-symbol "FIXNUM"))
 4727(define flonum-sym (string->canonical-symbol "FLONUM"))
 4728(define-namable-decl generic-sym 'arith)
 4729(define-namable-decl fixnum-sym 'arith)
 4730(define-namable-decl flonum-sym 'arith)
 4731(define (arith-implementation name decls)
 4732  (declaration-value 'arith name generic-sym decls))
 4733(define (cf source target-name . opts)
 4734  (let* ((dest (file-root source))
 4735         (module-name (file-name dest))
 4736         (info-port (if (memq 'verbose opts) (current-output-port) #f))
 4737         (result (compile-program
 4738                  (list **include-sym source)
 4739                  (if target-name target-name (default-target))
 4740                  opts
 4741                  module-name
 4742                  dest
 4743                  info-port)))
 4744    (if (and info-port (not (eq? info-port (current-output-port))))
 4745        (close-output-port info-port))
 4746    result))
 4747(define (ce source target-name . opts)
 4748  (let* ((dest "program")
 4749         (module-name "program")
 4750         (info-port (if (memq 'verbose opts) (current-output-port) #f))
 4751         (result (compile-program
 4752                  source
 4753                  (if target-name target-name (default-target))
 4754                  opts
 4755                  module-name
 4756                  dest
 4757                  info-port)))
 4758    (if (and info-port (not (eq? info-port (current-output-port))))
 4759        (close-output-port info-port))
 4760    result))
 4761(define wrap-program #f)
 4762(set! wrap-program (lambda (program) program))
 4763(define (compile-program program target-name opts module-name dest info-port)
 4764  (define (compiler-body)
 4765    (if (not (valid-module-name? module-name))
 4766        (compiler-error
 4767         "Invalid characters in file name (must be a symbol with no \"#\")")
 4768        (begin
 4769          (ptree.begin! info-port)
 4770          (virtual.begin!)
 4771          (select-target! target-name info-port)
 4772          (parse-program
 4773           (list (expression->source (wrap-program program) #f))
 4774           (make-global-environment)
 4775           module-name
 4776           (lambda (lst env c-intf)
 4777             (let ((parsed-program
 4778                    (map (lambda (x) (normalize-parse-tree (car x) (cdr x)))
 4779                         lst)))
 4780               (if (memq 'expansion opts)
 4781                   (let ((port (current-output-port)))
 4782                     (display "Expansion:" port)
 4783                     (newline port)
 4784                     (let loop ((l parsed-program))
 4785                       (if (pair? l)
 4786                           (let ((ptree (car l)))
 4787                             (pp-expression
 4788                              (parse-tree->expression ptree)
 4789                              port)
 4790                             (loop (cdr l)))))
 4791                     (newline port)))
 4792               (let ((module-init-proc
 4793                      (compile-parsed-program
 4794                       module-name
 4795                       parsed-program
 4796                       env
 4797                       c-intf
 4798                       info-port)))
 4799                 (if (memq 'report opts) (generate-report env))
 4800                 (if (memq 'gvm opts)
 4801                     (let ((gvm-port
 4802                            (open-output-file (string-append dest ".gvm"))))
 4803                       (virtual.dump module-init-proc gvm-port)
 4804                       (close-output-port gvm-port)))
 4805                 (target.dump module-init-proc dest c-intf opts)
 4806                 (dump-c-intf module-init-proc dest c-intf)))))
 4807          (unselect-target!)
 4808          (virtual.end!)
 4809          (ptree.end!)
 4810          #t)))
 4811  (let ((successful (with-exception-handling compiler-body)))
 4812    (if info-port
 4813        (if successful
 4814            (begin
 4815              (display "Compilation finished." info-port)
 4816              (newline info-port))
 4817            (begin
 4818              (display "Compilation terminated abnormally." info-port)
 4819              (newline info-port))))
 4820    successful))
 4821(define (valid-module-name? module-name)
 4822  (define (valid-char? c)
 4823    (and (not (memv c
 4824                    '(#\#
 4825                      #\;
 4826                      #\(
 4827                      #\)
 4828                      #\space
 4829                      #\[
 4830                      #\]
 4831                      #\{
 4832                      #\}
 4833                      #\"
 4834                      #\'
 4835                      #\`
 4836                      #\,)))
 4837         (not (char-whitespace? c))))
 4838  (let ((n (string-length module-name)))
 4839    (and (> n 0)
 4840         (not (string=? module-name "."))
 4841         (not (string->number module-name 10))
 4842         (let loop ((i 0))
 4843           (if (< i n)
 4844               (if (valid-char? (string-ref module-name i)) (loop (+ i 1)) #f)
 4845               #t)))))
 4846(define (dump-c-intf module-init-proc dest c-intf)
 4847  (let ((decls (c-intf-decls c-intf))
 4848        (procs (c-intf-procs c-intf))
 4849        (inits (c-intf-inits c-intf)))
 4850    (if (or (not (null? decls)) (not (null? procs)) (not (null? inits)))
 4851        (let* ((module-name (proc-obj-name module-init-proc))
 4852               (filename (string-append dest ".c"))
 4853               (port (open-output-file filename)))
 4854          (display "/* File: \"" port)
 4855          (display filename port)
 4856          (display "\", C-interface file produced by Gambit " port)
 4857          (display compiler-version port)
 4858          (display " */" port)
 4859          (newline port)
 4860          (display "#define " port)
 4861          (display c-id-prefix port)
 4862          (display "MODULE_NAME \"" port)
 4863          (display module-name port)
 4864          (display "\"" port)
 4865          (newline port)
 4866          (display "#define " port)
 4867          (display c-id-prefix port)
 4868          (display "MODULE_LINKER " port)
 4869          (display c-id-prefix port)
 4870          (display (scheme-id->c-id module-name) port)
 4871          (newline port)
 4872          (display "#define " port)
 4873          (display c-id-prefix port)
 4874          (display "VERSION \"" port)
 4875          (display compiler-version port)
 4876          (display "\"" port)
 4877          (newline port)
 4878          (if (not (null? procs))
 4879              (begin
 4880                (display "#define " port)
 4881                (display c-id-prefix port)
 4882                (display "C_PRC_COUNT " port)
 4883                (display (length procs) port)
 4884                (newline port)))
 4885          (display "#include \"gambit.h\"" port)
 4886          (newline port)
 4887          (display c-id-prefix port)
 4888          (display "BEGIN_MODULE" port)
 4889          (newline port)
 4890          (for-each
 4891           (lambda (x)
 4892             (let ((scheme-name (vector-ref x 0)))
 4893               (display c-id-prefix port)
 4894               (display "SUPPLY_PRM(" port)
 4895               (display c-id-prefix port)
 4896               (display "P_" port)
 4897               (display (scheme-id->c-id scheme-name) port)
 4898               (display ")" port)
 4899               (newline port)))
 4900           procs)
 4901          (newline port)
 4902          (for-each (lambda (x) (display x port) (newline port)) decls)
 4903          (if (not (null? procs))
 4904              (begin
 4905                (for-each
 4906                 (lambda (x)
 4907                   (let ((scheme-name (vector-ref x 0))
 4908                         (c-name (vector-ref x 1))
 4909                         (arity (vector-ref x 2))
 4910                         (def (vector-ref x 3)))
 4911                     (display c-id-prefix port)
 4912                     (display "BEGIN_C_COD(" port)
 4913                     (display c-name port)
 4914                     (display "," port)
 4915                     (display c-id-prefix port)
 4916                     (display "P_" port)
 4917                     (display (scheme-id->c-id scheme-name) port)
 4918                     (display "," port)
 4919                     (display arity port)
 4920                     (display ")" port)
 4921                     (newline port)
 4922                     (display "#undef ___ARG1" port)
 4923                     (newline port)
 4924                     (display "#define ___ARG1 ___R1" port)
 4925                     (newline port)
 4926                     (display "#undef ___ARG2" port)
 4927                     (newline port)
 4928                     (display "#define ___ARG2 ___R2" port)
 4929                     (newline port)
 4930                     (display "#undef ___ARG3" port)
 4931                     (newline port)
 4932                     (display "#define ___ARG3 ___R3" port)
 4933                     (newline port)
 4934                     (display "#undef ___RESULT" port)
 4935                     (newline port)
 4936                     (display "#define ___RESULT ___R1" port)
 4937                     (newline port)
 4938                     (display def port)
 4939                     (display c-id-prefix port)
 4940                     (display "END_C_COD" port)
 4941                     (newline port)))
 4942                 procs)
 4943                (newline port)
 4944                (display c-id-prefix port)
 4945                (display "BEGIN_C_PRC" port)
 4946                (newline port)
 4947                (let loop ((i 0) (lst procs))
 4948                  (if (not (null? lst))
 4949                      (let* ((x (car lst))
 4950                             (scheme-name (vector-ref x 0))
 4951                             (c-name (vector-ref x 1))
 4952                             (arity (vector-ref x 2)))
 4953                        (if (= i 0) (display " " port) (display "," port))
 4954                        (display c-id-prefix port)
 4955                        (display "DEF_C_PRC(" port)
 4956                        (display c-name port)
 4957                        (display "," port)
 4958                        (display c-id-prefix port)
 4959                        (display "P_" port)
 4960                        (display (scheme-id->c-id scheme-name) port)
 4961                        (display "," port)
 4962                        (display arity port)
 4963                        (display ")" port)
 4964                        (newline port)
 4965                        (loop (+ i 1) (cdr lst)))))
 4966                (display c-id-prefix port)
 4967                (display "END_C_PRC" port)
 4968                (newline port)))
 4969          (newline port)
 4970          (display c-id-prefix port)
 4971          (display "BEGIN_PRM" port)
 4972          (newline port)
 4973          (for-each (lambda (x) (display x port) (newline port)) inits)
 4974          (display c-id-prefix port)
 4975          (display "END_PRM" port)
 4976          (newline port)
 4977          (close-output-port port)))))
 4978(define (generate-report env)
 4979  (let ((vars (sort-variables (env-global-variables env)))
 4980        (decl (env-declarations env)))
 4981    (define (report title pred? vars wrote-something?)
 4982      (if (pair? vars)
 4983          (let ((var (car vars)))
 4984            (if (pred? var)
 4985                (begin
 4986                  (if (not wrote-something?)
 4987                      (begin (display " ") (display title) (newline)))
 4988                  (let loop1 ((l (var-refs var)) (r? #f) (c? #f))
 4989                    (if (pair? l)
 4990                        (let* ((x (car l)) (y (node-parent x)))
 4991                          (if (and y (app? y) (eq? x (app-oper y)))
 4992                              (loop1 (cdr l) r? #t)
 4993                              (loop1 (cdr l) #t c?)))
 4994                        (let loop2 ((l (var-sets var)) (d? #f) (a? #f))
 4995                          (if (pair? l)
 4996                              (if (set? (car l))
 4997                                  (loop2 (cdr l) d? #t)
 4998                                  (loop2 (cdr l) #t a?))
 4999                              (begin
 5000                                (display "  [")
 5001                                (if d? (display "D") (display " "))
 5002                                (if a? (display "A") (display " "))
 5003                                (if r? (display "R") (display " "))
 5004                                (if c? (display "C") (display " "))
 5005                                (display "] ")
 5006                                (display (var-name var))
 5007                                (newline))))))
 5008                  (report title pred? (cdr vars) #t))
 5009                (cons (car vars)
 5010                      (report title pred? (cdr vars) wrote-something?))))
 5011          (begin (if wrote-something? (newline)) '())))
 5012    (display "Global variable usage:")
 5013    (newline)
 5014    (newline)
 5015    (report "OTHERS"
 5016            (lambda (x) #t)
 5017            (report "EXTENDED"
 5018                    (lambda (x) (target.prim-info (var-name x)))
 5019                    (report "STANDARD"
 5020                            (lambda (x) (standard-procedure (var-name x) decl))
 5021                            vars
 5022                            #f)
 5023                    #f)
 5024            #f)))
 5025(define (compile-parsed-program module-name program env c-intf info-port)
 5026  (if info-port (display "Compiling:" info-port))
 5027  (set! trace-indentation 0)
 5028  (set! *bbs* (make-bbs))
 5029  (set! *global-env* env)
 5030  (set! proc-queue '())
 5031  (set! constant-vars '())
 5032  (set! known-procs '())
 5033  (restore-context (make-context 0 '() (list ret-var) '() (entry-poll) #f))
 5034  (let* ((entry-lbl (bbs-new-lbl! *bbs*))
 5035         (body-lbl (bbs-new-lbl! *bbs*))
 5036         (frame (current-frame ret-var-set))
 5037         (comment (if (null? program) #f (source-comment (car program)))))
 5038    (bbs-entry-lbl-num-set! *bbs* entry-lbl)
 5039    (set! entry-bb
 5040          (make-bb (make-label-entry entry-lbl 0 0 #f #f frame comment) *bbs*))
 5041    (bb-put-branch! entry-bb (make-jump (make-lbl body-lbl) #f #f frame #f))
 5042    (set! *bb* (make-bb (make-label-simple body-lbl frame comment) *bbs*))
 5043    (let loop1 ((l (c-intf-procs c-intf)))
 5044      (if (not (null? l))
 5045          (let* ((x (car l))
 5046                 (name (vector-ref x 0))
 5047                 (sym (string->canonical-symbol name))
 5048                 (var (env-lookup-global-var *global-env* sym)))
 5049            (add-constant-var
 5050             var
 5051             (make-obj (make-proc-obj name #t #f 0 #t '() '(#f))))
 5052            (loop1 (cdr l)))))
 5053    (let loop2 ((l program))
 5054      (if (not (null? l))
 5055          (let ((node (car l)))
 5056            (if (def? node)
 5057                (let* ((var (def-var node)) (val (global-val var)))
 5058                  (if (and val (prc? val))
 5059                      (add-constant-var
 5060                       var
 5061                       (make-obj
 5062                        (make-proc-obj
 5063                         (symbol->string (var-name var))
 5064                         #t
 5065                         #f
 5066                         (call-pattern val)
 5067                         #t
 5068                         '()
 5069                         '(#f)))))))
 5070            (loop2 (cdr l)))))
 5071    (let loop3 ((l program))
 5072      (if (null? l)
 5073          (let ((ret-opnd (var->opnd ret-var)))
 5074            (seal-bb #t 'return)
 5075            (dealloc-slots nb-slots)
 5076            (bb-put-branch!
 5077             *bb*
 5078             (make-jump ret-opnd #f #f (current-frame (set-empty)) #f)))
 5079          (let ((node (car l)))
 5080            (if (def? node)
 5081                (begin
 5082                  (gen-define (def-var node) (def-val node) info-port)
 5083                  (loop3 (cdr l)))
 5084                (if (null? (cdr l))
 5085                    (gen-node node ret-var-set 'tail)
 5086                    (begin
 5087                      (gen-node node ret-var-set 'need)
 5088                      (loop3 (cdr l))))))))
 5089    (let loop4 ()
 5090      (if (pair? proc-queue)
 5091          (let ((x (car proc-queue)))
 5092            (set! proc-queue (cdr proc-queue))
 5093            (gen-proc (car x) (cadr x) (caddr x) info-port)
 5094            (trace-unindent info-port)
 5095            (loop4))))
 5096    (if info-port (begin (newline info-port) (newline info-port)))
 5097    (bbs-purify! *bbs*)
 5098    (let ((proc (make-proc-obj
 5099                 (string-append "#!" module-name)
 5100                 #t
 5101                 *bbs*
 5102                 '(0)
 5103                 #t
 5104                 '()
 5105                 '(#f))))
 5106      (set! *bb* '())
 5107      (set! *bbs* '())
 5108      (set! *global-env* '())
 5109      (set! proc-queue '())
 5110      (set! constant-vars '())
 5111      (set! known-procs '())
 5112      (clear-context)
 5113      proc)))
 5114(define *bb* '())
 5115(define *bbs* '())
 5116(define *global-env* '())
 5117(define proc-queue '())
 5118(define constant-vars '())
 5119(define known-procs '())
 5120(define trace-indentation '())
 5121(define (trace-indent info-port)
 5122  (set! trace-indentation (+ trace-indentation 1))
 5123  (if info-port
 5124      (begin
 5125        (newline info-port)
 5126        (let loop ((i trace-indentation))
 5127          (if (> i 0) (begin (display "  " info-port) (loop (- i 1))))))))
 5128(define (trace-unindent info-port)
 5129  (set! trace-indentation (- trace-indentation 1)))
 5130(define (gen-define var node info-port)
 5131  (if (prc? node)
 5132      (let* ((p-bbs *bbs*)
 5133             (p-bb *bb*)
 5134             (p-proc-queue proc-queue)
 5135             (p-known-procs known-procs)
 5136             (p-context (current-context))
 5137             (bbs (make-bbs))
 5138             (lbl1 (bbs-new-lbl! bbs))
 5139             (lbl2 (bbs-new-lbl! bbs))
 5140             (context (entry-context node '()))
 5141             (frame (context->frame
 5142                     context
 5143                     (set-union (free-variables (prc-body node)) ret-var-set)))
 5144             (bb1 (make-bb (make-label-entry
 5145                            lbl1
 5146                            (length (prc-parms node))
 5147                            (prc-min node)
 5148                            (prc-rest node)
 5149                            #f
 5150                            frame
 5151                            (source-comment node))
 5152                           bbs))
 5153             (bb2 (make-bb (make-label-simple lbl2 frame (source-comment node))
 5154                           bbs)))
 5155        (define (do-body)
 5156          (gen-proc node bb2 context info-port)
 5157          (let loop ()
 5158            (if (pair? proc-queue)
 5159                (let ((x (car proc-queue)))
 5160                  (set! proc-queue (cdr proc-queue))
 5161                  (gen-proc (car x) (cadr x) (caddr x) info-port)
 5162                  (trace-unindent info-port)
 5163                  (loop))))
 5164          (trace-unindent info-port)
 5165          (bbs-purify! *bbs*))
 5166        (context-entry-bb-set! context bb1)
 5167        (bbs-entry-lbl-num-set! bbs lbl1)
 5168        (bb-put-branch! bb1 (make-jump (make-lbl lbl2) #f #f frame #f))
 5169        (set! *bbs* bbs)
 5170        (set! proc-queue '())
 5171        (set! known-procs '())
 5172        (if (constant-var? var)
 5173            (let-constant-var
 5174             var
 5175             (make-lbl lbl1)
 5176             (lambda () (add-known-proc lbl1 node) (do-body)))
 5177            (do-body))
 5178        (set! *bbs* p-bbs)
 5179        (set! *bb* p-bb)
 5180        (set! proc-queue p-proc-queue)
 5181        (set! known-procs p-known-procs)
 5182        (restore-context p-context)
 5183        (let* ((x (assq var constant-vars))
 5184               (proc (if x
 5185                         (let ((p (cdr x)))
 5186                           (proc-obj-code-set! (obj-val p) bbs)
 5187                           p)
 5188                         (make-obj
 5189                          (make-proc-obj
 5190                           (symbol->string (var-name var))
 5191                           #f
 5192                           bbs
 5193                           (call-pattern node)
 5194                           #t
 5195                           '()
 5196                           '(#f))))))
 5197          (put-copy
 5198           proc
 5199           (make-glo (var-name var))
 5200           #f
 5201           ret-var-set
 5202           (source-comment node))))
 5203      (put-copy
 5204       (gen-node node ret-var-set 'need)
 5205       (make-glo (var-name var))
 5206       #f
 5207       ret-var-set
 5208       (source-comment node))))
 5209(define (call-pattern node)
 5210  (make-pattern (prc-min node) (length (prc-parms node)) (prc-rest node)))
 5211(define (make-context nb-slots slots regs closed poll entry-bb)
 5212  (vector nb-slots slots regs closed poll entry-bb))
 5213(define (context-nb-slots x) (vector-ref x 0))
 5214(define (context-slots x) (vector-ref x 1))
 5215(define (context-regs x) (vector-ref x 2))
 5216(define (context-closed x) (vector-ref x 3))
 5217(define (context-poll x) (vector-ref x 4))
 5218(define (context-entry-bb x) (vector-ref x 5))
 5219(define (context-entry-bb-set! x y) (vector-set! x 5 y))
 5220(define nb-slots '())
 5221(define slots '())
 5222(define regs '())
 5223(define closed '())
 5224(define poll '())
 5225(define entry-bb '())
 5226(define (restore-context context)
 5227  (set! nb-slots (context-nb-slots context))
 5228  (set! slots (context-slots context))
 5229  (set! regs (context-regs context))
 5230  (set! closed (context-closed context))
 5231  (set! poll (context-poll context))
 5232  (set! entry-bb (context-entry-bb context)))
 5233(define (clear-context)
 5234  (restore-context (make-context '() '() '() '() '() '())))
 5235(define (current-context)
 5236  (make-context nb-slots slots regs closed poll entry-bb))
 5237(define (current-frame live) (make-frame nb-slots slots regs closed live))
 5238(define (context->frame context live)
 5239  (make-frame
 5240   (context-nb-slots context)
 5241   (context-slots context)
 5242   (context-regs context)
 5243   (context-closed context)
 5244   live))
 5245(define (make-poll since-entry? delta) (cons since-entry? delta))
 5246(define (poll-since-entry? x) (car x))
 5247(define (poll-delta x) (cdr x))
 5248(define (entry-poll) (make-poll #f (- poll-period poll-head)))
 5249(define (return-poll poll)
 5250  (let ((delta (poll-delta poll)))
 5251    (make-poll (poll-since-entry? poll) (+ poll-head (max delta poll-tail)))))
 5252(define (poll-merge poll other-poll)
 5253  (make-poll
 5254   (or (poll-since-entry? poll) (poll-since-entry? other-poll))
 5255   (max (poll-delta poll) (poll-delta other-poll))))
 5256(define poll-period #f)
 5257(set! poll-period 90)
 5258(define poll-head #f)
 5259(set! poll-head 15)
 5260(define poll-tail #f)
 5261(set! poll-tail 15)
 5262(define (entry-context proc closed)
 5263  (define (empty-vars-list n)
 5264    (if (> n 0) (cons empty-var (empty-vars-list (- n 1))) '()))
 5265  (let* ((parms (prc-parms proc))
 5266         (pc (target.label-info
 5267              (prc-min proc)
 5268              (length parms)
 5269              (prc-rest proc)
 5270              (not (null? closed))))
 5271         (fs (pcontext-fs pc))
 5272         (slots-list (empty-vars-list fs))
 5273         (regs-list (empty-vars-list target.nb-regs)))
 5274    (define (assign-var-to-loc var loc)
 5275      (let ((x (cond ((reg? loc)
 5276                      (let ((i (reg-num loc)))
 5277                        (if (<= i target.nb-regs)
 5278                            (nth-after regs-list i)
 5279                            (compiler-internal-error
 5280                             "entry-context, reg out of bound in back-end's pcontext"))))
 5281                     ((stk? loc)
 5282                      (let ((i (stk-num loc)))
 5283                        (if (<= i fs)
 5284                            (nth-after slots-list (- fs i))
 5285                            (compiler-internal-error
 5286                             "entry-context, stk out of bound in back-end's pcontext"))))
 5287                     (else
 5288                      (compiler-internal-error
 5289                       "entry-context, loc other than reg or stk in back-end's pcontext")))))
 5290        (if (eq? (car x) empty-var)
 5291            (set-car! x var)
 5292            (compiler-internal-error
 5293             "entry-context, duplicate location in back-end's pcontext"))))
 5294    (let loop ((l (pcontext-map pc)))
 5295      (if (not (null? l))
 5296          (let* ((couple (car l)) (name (car couple)) (loc (cdr couple)))
 5297            (cond ((eq? name 'return) (assign-var-to-loc ret-var loc))
 5298                  ((eq? name 'closure-env)
 5299                   (assign-var-to-loc closure-env-var loc))
 5300                  (else (assign-var-to-loc (list-ref parms (- name 1)) loc)))
 5301            (loop (cdr l)))))
 5302    (make-context fs slots-list regs-list closed (entry-poll) #f)))
 5303(define (get-var opnd)
 5304  (cond ((glo? opnd) (env-lookup-global-var *global-env* (glo-name opnd)))
 5305        ((reg? opnd) (list-ref regs (reg-num opnd)))
 5306        ((stk? opnd) (list-ref slots (- nb-slots (stk-num opnd))))
 5307        (else
 5308         (compiler-internal-error
 5309          "get-var, location must be global, register or stack slot"))))
 5310(define (put-var opnd new)
 5311  (define (put-v opnd new)
 5312    (cond ((reg? opnd) (set! regs (replace-nth regs (reg-num opnd) new)))
 5313          ((stk? opnd)
 5314           (set! slots (replace-nth slots (- nb-slots (stk-num opnd)) new)))
 5315          (else
 5316           (compiler-internal-error
 5317            "put-var, location must be register or stack slot, for var:"
 5318            (var-name new)))))
 5319  (if (eq? new ret-var)
 5320      (let ((x (var->opnd ret-var))) (and x (put-v x empty-var))))
 5321  (put-v opnd new))
 5322(define (flush-regs) (set! regs '()))
 5323(define (push-slot)
 5324  (set! nb-slots (+ nb-slots 1))
 5325  (set! slots (cons empty-var slots)))
 5326(define (dealloc-slots n)
 5327  (set! nb-slots (- nb-slots n))
 5328  (set! slots (nth-after slots n)))
 5329(define (pop-slot) (dealloc-slots 1))
 5330(define (replace-nth l i v)
 5331  (if (null? l)
 5332      (if (= i 0) (list v) (cons empty-var (replace-nth l (- i 1) v)))
 5333      (if (= i 0)
 5334          (cons v (cdr l))
 5335          (cons (car l) (replace-nth (cdr l) (- i 1) v)))))
 5336(define (live-vars live)
 5337  (if (not (set-empty? (set-intersection live (list->set closed))))
 5338      (set-adjoin live closure-env-var)
 5339      live))
 5340(define (dead-slots live)
 5341  (let ((live-v (live-vars live)))
 5342    (define (loop s l i)
 5343      (cond ((null? l) (list->set (reverse s)))
 5344            ((set-member? (car l) live-v) (loop s (cdr l) (- i 1)))
 5345            (else (loop (cons i s) (cdr l) (- i 1)))))
 5346    (loop '() slots nb-slots)))
 5347(define (live-slots live)
 5348  (let ((live-v (live-vars live)))
 5349    (define (loop s l i)
 5350      (cond ((null? l) (list->set (reverse s)))
 5351            ((set-member? (car l) live-v) (loop (cons i s) (cdr l) (- i 1)))
 5352            (else (loop s (cdr l) (- i 1)))))
 5353    (loop '() slots nb-slots)))
 5354(define (dead-regs live)
 5355  (let ((live-v (live-vars live)))
 5356    (define (loop s l i)
 5357      (cond ((>= i target.nb-regs) (list->set (reverse s)))
 5358            ((null? l) (loop (cons i s) l (+ i 1)))
 5359            ((and (set-member? (car l) live-v) (not (memq (car l) slots)))
 5360             (loop s (cdr l) (+ i 1)))
 5361            (else (loop (cons i s) (cdr l) (+ i 1)))))
 5362    (loop '() regs 0)))
 5363(define (live-regs live)
 5364  (let ((live-v (live-vars live)))
 5365    (define (loop s l i)
 5366      (cond ((null? l) (list->set (reverse s)))
 5367            ((and (set-member? (car l) live-v) (not (memq (car l) slots)))
 5368             (loop (cons i s) (cdr l) (+ i 1)))
 5369            (else (loop s (cdr l) (+ i 1)))))
 5370    (loop '() regs 0)))
 5371(define (lowest-dead-slot live)
 5372  (make-stk (or (lowest (dead-slots live)) (+ nb-slots 1))))
 5373(define (highest-live-slot live) (make-stk (or (highest (live-slots live)) 0)))
 5374(define (lowest-dead-reg live)
 5375  (let ((x (lowest (set-remove (dead-regs live) 0)))) (if x (make-reg x) #f)))
 5376(define (highest-dead-reg live)
 5377  (let ((x (highest (dead-regs live)))) (if x (make-reg x) #f)))
 5378(define (highest set) (if (set-empty? set) #f (apply max (set->list set))))
 5379(define (lowest set) (if (set-empty? set) #f (apply min (set->list set))))
 5380(define (above set n) (set-keep (lambda (x) (> x n)) set))
 5381(define (below set n) (set-keep (lambda (x) (< x n)) set))
 5382(define (var->opnd var)
 5383  (let ((x (assq var constant-vars)))
 5384    (if x
 5385        (cdr x)
 5386        (if (global? var)
 5387            (make-glo (var-name var))
 5388            (let ((n (pos-in-list var regs)))
 5389              (if n
 5390                  (make-reg n)
 5391                  (let ((n (pos-in-list var slots)))
 5392                    (if n
 5393                        (make-stk (- nb-slots n))
 5394                        (let ((n (pos-in-list var closed)))
 5395                          (if n
 5396                              (make-clo (var->opnd closure-env-var) (+ n 1))
 5397                              (compiler-internal-error
 5398                               "var->opnd, variable is not accessible:"
 5399                               (var-name var))))))))))))
 5400(define (source-comment node)
 5401  (let ((x (make-comment))) (comment-put! x 'source (node-source node)) x))
 5402(define (sort-variables lst)
 5403  (sort-list
 5404   lst
 5405   (lambda (x y)
 5406     (string<? (symbol->string (var-name x)) (symbol->string (var-name y))))))
 5407(define (add-constant-var var opnd)
 5408  (set! constant-vars (cons (cons var opnd) constant-vars)))
 5409(define (let-constant-var var opnd thunk)
 5410  (let* ((x (assq var constant-vars)) (temp (cdr x)))
 5411    (set-cdr! x opnd)
 5412    (thunk)
 5413    (set-cdr! x temp)))
 5414(define (constant-var? var) (assq var constant-vars))
 5415(define (not-constant-var? var) (not (constant-var? var)))
 5416(define (add-known-proc label proc)
 5417  (set! known-procs (cons (cons label proc) known-procs)))
 5418(define (gen-proc proc bb context info-port)
 5419  (trace-indent info-port)
 5420  (if info-port
 5421      (if (prc-name proc)
 5422          (display (prc-name proc) info-port)
 5423          (display "\"unknown\"" info-port)))
 5424  (let ((lbl (bb-lbl-num bb))
 5425        (live (set-union (free-variables (prc-body proc)) ret-var-set)))
 5426    (set! *bb* bb)
 5427    (restore-context context)
 5428    (gen-node (prc-body proc) ret-var-set 'tail)))
 5429(define (schedule-gen-proc proc closed-list)
 5430  (let* ((lbl1 (bbs-new-lbl! *bbs*))
 5431         (lbl2 (bbs-new-lbl! *bbs*))
 5432         (context (entry-context proc closed-list))
 5433         (frame (context->frame
 5434                 context
 5435                 (set-union (free-variables (prc-body proc)) ret-var-set)))
 5436         (bb1 (make-bb (make-label-entry
 5437                        lbl1
 5438                        (length (prc-parms proc))
 5439                        (prc-min proc)
 5440                        (prc-rest proc)
 5441                        (not (null? closed-list))
 5442                        frame
 5443                        (source-comment proc))
 5444                       *bbs*))
 5445         (bb2 (make-bb (make-label-simple lbl2 frame (source-comment proc))
 5446                       *bbs*)))
 5447    (context-entry-bb-set! context bb1)
 5448    (bb-put-branch! bb1 (make-jump (make-lbl lbl2) #f #f frame #f))
 5449    (set! proc-queue (cons (list proc bb2 context) proc-queue))
 5450    (make-lbl lbl1)))
 5451(define (gen-node node live why)
 5452  (cond ((cst? node) (gen-return (make-obj (cst-val node)) why node))
 5453        ((ref? node)
 5454         (let* ((var (ref-var node)) (name (var-name var)))
 5455           (gen-return
 5456            (cond ((eq? why 'side) (make-obj undef-object))
 5457                  ((global? var)
 5458                   (let ((prim (target.prim-info* name (node-decl node))))
 5459                     (if prim (make-obj prim) (var->opnd var))))
 5460                  (else (var->opnd var)))
 5461            why
 5462            node)))
 5463        ((set? node)
 5464         (let* ((src (gen-node
 5465                      (set-val node)
 5466                      (set-adjoin live (set-var node))
 5467                      'keep))
 5468                (dst (var->opnd (set-var node))))
 5469           (put-copy src dst #f live (source-comment node))
 5470           (gen-return (make-obj undef-object) why node)))
 5471        ((def? node)
 5472         (compiler-internal-error
 5473          "gen-node, 'def' node not at root of parse tree"))
 5474        ((tst? node) (gen-tst node live why))
 5475        ((conj? node) (gen-conj/disj node live why))
 5476        ((disj? node) (gen-conj/disj node live why))
 5477        ((prc? node)
 5478         (let* ((closed (not-constant-closed-vars node))
 5479                (closed-list (sort-variables (set->list closed)))
 5480                (proc-lbl (schedule-gen-proc node closed-list)))
 5481           (let ((opnd (if (null? closed-list)
 5482                           (begin
 5483                             (add-known-proc (lbl-num proc-lbl) node)
 5484                             proc-lbl)
 5485                           (begin
 5486                             (dealloc-slots
 5487                              (- nb-slots
 5488                                 (stk-num (highest-live-slot
 5489                                           (set-union closed live)))))
 5490                             (push-slot)
 5491                             (let ((slot (make-stk nb-slots))
 5492                                   (var (make-temp-var 'closure)))
 5493                               (put-var slot var)
 5494                               (bb-put-non-branch!
 5495                                *bb*
 5496                                (make-close
 5497                                 (list (make-closure-parms
 5498                                        slot
 5499                                        (lbl-num proc-lbl)
 5500                                        (map var->opnd closed-list)))
 5501                                 (current-frame (set-adjoin live var))
 5502                                 (source-comment node)))
 5503                               slot)))))
 5504             (gen-return opnd why node))))
 5505        ((app? node) (gen-call node live why))
 5506        ((fut? node) (gen-fut node live why))
 5507        (else
 5508         (compiler-internal-error
 5509          "gen-node, unknown parse tree node type:"
 5510          node))))
 5511(define (gen-return opnd why node)
 5512  (cond ((eq? why 'tail)
 5513         (let ((var (make-temp-var 'result)))
 5514           (put-copy
 5515            opnd
 5516            target.proc-result
 5517            var
 5518            ret-var-set
 5519            (source-comment node))
 5520           (let ((ret-opnd (var->opnd ret-var)))
 5521             (seal-bb (intrs-enabled? (node-decl node)) 'return)
 5522             (dealloc-slots nb-slots)
 5523             (bb-put-branch!
 5524              *bb*
 5525              (make-jump
 5526               ret-opnd
 5527               #f
 5528               #f
 5529               (current-frame (set-singleton var))
 5530               #f)))))
 5531        (else opnd)))
 5532(define (not-constant-closed-vars val)
 5533  (set-keep not-constant-var? (free-variables val)))
 5534(define (predicate node live cont)
 5535  (define (cont* true-lbl false-lbl) (cont false-lbl true-lbl))
 5536  (define (generic-true-test)
 5537    (predicate-test node live **not-proc-obj '0 (list node) cont*))
 5538  (cond ((or (conj? node) (disj? node)) (predicate-conj/disj node live cont))
 5539        ((app? node)
 5540         (let ((proc (node->proc (app-oper node))))
 5541           (if proc
 5542               (let ((spec (specialize-for-call proc (node-decl node))))
 5543                 (if (and (proc-obj-test spec)
 5544                          (nb-args-conforms?
 5545                           (length (app-args node))
 5546                           (proc-obj-call-pat spec)))
 5547                     (if (eq? spec **not-proc-obj)
 5548                         (predicate (car (app-args node)) live cont*)
 5549                         (predicate-test
 5550                          node
 5551                          live
 5552                          spec
 5553                          (proc-obj-strict-pat proc)
 5554                          (app-args node)
 5555                          cont))
 5556                     (generic-true-test)))
 5557               (generic-true-test))))
 5558        (else (generic-true-test))))
 5559(define (predicate-conj/disj node live cont)
 5560  (let* ((pre (if (conj? node) (conj-pre node) (disj-pre node)))
 5561         (alt (if (conj? node) (conj-alt node) (disj-alt node)))
 5562         (alt-live (set-union live (free-variables alt))))
 5563    (predicate
 5564     pre
 5565     alt-live
 5566     (lambda (true-lbl false-lbl)
 5567       (let ((pre-context (current-context)))
 5568         (set! *bb*
 5569               (make-bb (make-label-simple
 5570                         (if (conj? node) true-lbl false-lbl)
 5571                         (current-frame alt-live)
 5572                         (source-comment alt))
 5573                        *bbs*))
 5574         (predicate
 5575          alt
 5576          live
 5577          (lambda (true-lbl2 false-lbl2)
 5578            (let ((alt-context (current-context)))
 5579              (restore-context pre-context)
 5580              (set! *bb*
 5581                    (make-bb (make-label-simple
 5582                              (if (conj? node) false-lbl true-lbl)
 5583                              (current-frame live)
 5584                              (source-comment alt))
 5585                             *bbs*))
 5586              (merge-contexts-and-seal-bb
 5587               alt-context
 5588               live
 5589               (intrs-enabled? (node-decl node))
 5590               'internal
 5591               (source-comment node))
 5592              (bb-put-branch!
 5593               *bb*
 5594               (make-jump
 5595                (make-lbl (if (conj? node) false-lbl2 true-lbl2))
 5596                #f
 5597                #f
 5598                (current-frame live)
 5599                #f))
 5600              (cont true-lbl2 false-lbl2)))))))))
 5601(define (predicate-test node live test strict-pat args cont)
 5602  (let loop ((args* args) (liv live) (vars* '()))
 5603    (if (not (null? args*))
 5604        (let* ((needed (vals-live-vars liv (cdr args*)))
 5605               (var (save-var
 5606                     (gen-node (car args*) needed 'need)
 5607                     (make-temp-var 'predicate)
 5608                     needed
 5609                     (source-comment (car args*)))))
 5610          (loop (cdr args*) (set-adjoin liv var) (cons var vars*)))
 5611        (let* ((true-lbl (bbs-new-lbl! *bbs*))
 5612               (false-lbl (bbs-new-lbl! *bbs*)))
 5613          (seal-bb (intrs-enabled? (node-decl node)) 'internal)
 5614          (bb-put-branch!
 5615           *bb*
 5616           (make-ifjump
 5617            test
 5618            (map var->opnd (reverse vars*))
 5619            true-lbl
 5620            false-lbl
 5621            #f
 5622            (current-frame live)
 5623            (source-comment node)))
 5624          (cont true-lbl false-lbl)))))
 5625(define (gen-tst node live why)
 5626  (let ((pre (tst-pre node)) (con (tst-con node)) (alt (tst-alt node)))
 5627    (predicate
 5628     pre
 5629     (set-union live (free-variables con) (free-variables alt))
 5630     (lambda (true-lbl false-lbl)
 5631       (let ((pre-context (current-context))
 5632             (true-bb (make-bb (make-label-simple
 5633                                true-lbl
 5634                                (current-frame
 5635                                 (set-union live (free-variables con)))
 5636                                (source-comment con))
 5637                               *bbs*))
 5638             (false-bb
 5639              (make-bb (make-label-simple
 5640                        false-lbl
 5641                        (current-frame (set-union live (free-variables alt)))
 5642                        (source-comment alt))
 5643                       *bbs*)))
 5644         (set! *bb* true-bb)
 5645         (let ((con-opnd (gen-node con live why)))
 5646           (if (eq? why 'tail)
 5647               (begin
 5648                 (restore-context pre-context)
 5649                 (set! *bb* false-bb)
 5650                 (gen-node alt live why))
 5651               (let* ((result-var (make-temp-var 'result))
 5652                      (live-after (set-adjoin live result-var)))
 5653                 (save-opnd-to-reg
 5654                  con-opnd
 5655                  target.proc-result
 5656                  result-var
 5657                  live
 5658                  (source-comment con))
 5659                 (let ((con-context (current-context)) (con-bb *bb*))
 5660                   (restore-context pre-context)
 5661                   (set! *bb* false-bb)
 5662                   (save-opnd-to-reg
 5663                    (gen-node alt live why)
 5664                    target.proc-result
 5665                    result-var
 5666                    live
 5667                    (source-comment alt))
 5668                   (let ((next-lbl (bbs-new-lbl! *bbs*)) (alt-bb *bb*))
 5669                     (if (> (context-nb-slots con-context) nb-slots)
 5670                         (begin
 5671                           (seal-bb (intrs-enabled? (node-decl node))
 5672                                    'internal)
 5673                           (let ((alt-context (current-context)))
 5674                             (restore-context con-context)
 5675                             (set! *bb* con-bb)
 5676                             (merge-contexts-and-seal-bb
 5677                              alt-context
 5678                              live-after
 5679                              (intrs-enabled? (node-decl node))
 5680                              'internal
 5681                              (source-comment node))))
 5682                         (let ((alt-context (current-context)))
 5683                           (restore-context con-context)
 5684                           (set! *bb* con-bb)
 5685                           (seal-bb (intrs-enabled? (node-decl node))
 5686                                    'internal)
 5687                           (let ((con-context* (current-context)))
 5688                             (restore-context alt-context)
 5689                             (set! *bb* alt-bb)
 5690                             (merge-contexts-and-seal-bb
 5691                              con-context*
 5692                              live-after
 5693                              (intrs-enabled? (node-decl node))
 5694                              'internal
 5695                              (source-comment node)))))
 5696                     (let ((frame (current-frame live-after)))
 5697                       (bb-put-branch!
 5698                        con-bb
 5699                        (make-jump (make-lbl next-lbl) #f #f frame #f))
 5700                       (bb-put-branch!
 5701                        alt-bb
 5702                        (make-jump (make-lbl next-lbl) #f #f frame #f))
 5703                       (set! *bb*
 5704                             (make-bb (make-label-simple
 5705                                       next-lbl
 5706                                       frame
 5707                                       (source-comment node))
 5708                                      *bbs*))
 5709                       target.proc-result)))))))))))
 5710(define (nb-args-conforms? n call-pat) (pattern-member? n call-pat))
 5711(define (merge-contexts-and-seal-bb other-context live poll? where comment)
 5712  (let ((live-v (live-vars live))
 5713        (other-nb-slots (context-nb-slots other-context))
 5714        (other-regs (context-regs other-context))
 5715        (other-slots (context-slots other-context))
 5716        (other-poll (context-poll other-context))
 5717        (other-entry-bb (context-entry-bb other-context)))
 5718    (let loop1 ((i (- target.nb-regs 1)))
 5719      (if (>= i 0)
 5720          (let ((other-var (reg->var other-regs i)) (var (reg->var regs i)))
 5721            (if (and (not (eq? var other-var)) (set-member? other-var live-v))
 5722                (let ((r (make-reg i)))
 5723                  (put-var r empty-var)
 5724                  (if (not (or (not (set-member? var live-v))
 5725                               (memq var regs)
 5726                               (memq var slots)))
 5727                      (let ((top (make-stk (+ nb-slots 1))))
 5728                        (put-copy r top var live-v comment)))
 5729                  (put-copy (var->opnd other-var) r other-var live-v comment)))
 5730            (loop1 (- i 1)))))
 5731    (let loop2 ((i 1))
 5732      (if (<= i other-nb-slots)
 5733          (let ((other-var (stk->var other-slots i)) (var (stk->var slots i)))
 5734            (if (and (not (eq? var other-var)) (set-member? other-var live-v))
 5735                (let ((s (make-stk i)))
 5736                  (if (<= i nb-slots) (put-var s empty-var))
 5737                  (if (not (or (not (set-member? var live-v))
 5738                               (memq var regs)
 5739                               (memq var slots)))
 5740                      (let ((top (make-stk (+ nb-slots 1))))
 5741                        (put-copy s top var live-v comment)))
 5742                  (put-copy (var->opnd other-var) s other-var live-v comment))
 5743                (if (> i nb-slots)
 5744                    (let ((top (make-stk (+ nb-slots 1))))
 5745                      (put-copy
 5746                       (make-obj undef-object)
 5747                       top
 5748                       empty-var
 5749                       live-v
 5750                       comment))))
 5751            (loop2 (+ i 1)))))
 5752    (dealloc-slots (- nb-slots other-nb-slots))
 5753    (let loop3 ((i (- target.nb-regs 1)))
 5754      (if (>= i 0)
 5755          (let ((other-var (reg->var other-regs i)) (var (reg->var regs i)))
 5756            (if (not (eq? var other-var)) (put-var (make-reg i) empty-var))
 5757            (loop3 (- i 1)))))
 5758    (let loop4 ((i 1))
 5759      (if (<= i other-nb-slots)
 5760          (let ((other-var (stk->var other-slots i)) (var (stk->var slots i)))
 5761            (if (not (eq? var other-var)) (put-var (make-stk i) empty-var))
 5762            (loop4 (+ i 1)))))
 5763    (seal-bb poll? where)
 5764    (set! poll (poll-merge poll other-poll))
 5765    (if (not (eq? entry-bb other-entry-bb))
 5766        (compiler-internal-error
 5767         "merge-contexts-and-seal-bb, entry-bb's do not agree"))))
 5768(define (seal-bb poll? where)
 5769  (define (my-last-pair l) (if (pair? (cdr l)) (my-last-pair (cdr l)) l))
 5770  (define (poll-at split-point)
 5771    (let loop ((i 0) (l1 (bb-non-branch-instrs *bb*)) (l2 '()))
 5772      (if (< i split-point)
 5773          (loop (+ i 1) (cdr l1) (cons (car l1) l2))
 5774          (let* ((label-instr (bb-label-instr *bb*))
 5775                 (non-branch-instrs1 (reverse l2))
 5776                 (non-branch-instrs2 l1)
 5777                 (frame (gvm-instr-frame
 5778                         (car (my-last-pair
 5779                               (cons label-instr non-branch-instrs1)))))
 5780                 (prec-bb (make-bb label-instr *bbs*))
 5781                 (new-lbl (bbs-new-lbl! *bbs*)))
 5782            (bb-non-branch-instrs-set! prec-bb non-branch-instrs1)
 5783            (bb-put-branch!
 5784             prec-bb
 5785             (make-jump (make-lbl new-lbl) #f #t frame #f))
 5786            (bb-label-instr-set! *bb* (make-label-simple new-lbl frame #f))
 5787            (bb-non-branch-instrs-set! *bb* non-branch-instrs2)
 5788            (set! poll (make-poll #t 0))))))
 5789  (define (poll-at-end) (poll-at (length (bb-non-branch-instrs *bb*))))
 5790  (define (impose-polling-constraints)
 5791    (let ((n (+ (length (bb-non-branch-instrs *bb*)) 1))
 5792          (delta (poll-delta poll)))
 5793      (if (> (+ delta n) poll-period)
 5794          (begin
 5795            (poll-at (max (- poll-period delta) 0))
 5796            (impose-polling-constraints)))))
 5797  (if poll? (impose-polling-constraints))
 5798  (let* ((n (+ (length (bb-non-branch-instrs *bb*)) 1))
 5799         (delta (+ (poll-delta poll) n))
 5800         (since-entry? (poll-since-entry? poll)))
 5801    (if (and poll?
 5802             (case where
 5803               ((call) (> delta (- poll-period poll-head)))
 5804               ((tail-call) (> delta poll-tail))
 5805               ((return) (and since-entry? (> delta (+ poll-head poll-tail))))
 5806               ((internal) #f)
 5807               (else
 5808                (compiler-internal-error "seal-bb, unknown 'where':" where))))
 5809        (poll-at-end)
 5810        (set! poll (make-poll since-entry? delta)))))
 5811(define (reg->var regs i)
 5812  (cond ((null? regs) '())
 5813        ((> i 0) (reg->var (cdr regs) (- i 1)))
 5814        (else (car regs))))
 5815(define (stk->var slots i)
 5816  (let ((j (- (length slots) i))) (if (< j 0) '() (list-ref slots j))))
 5817(define (gen-conj/disj node live why)
 5818  (let ((pre (if (conj? node) (conj-pre node) (disj-pre node)))
 5819        (alt (if (conj? node) (conj-alt node) (disj-alt node))))
 5820    (let ((needed (set-union live (free-variables alt)))
 5821          (bool? (boolean-value? pre))
 5822          (predicate-var (make-temp-var 'predicate)))
 5823      (define (general-predicate node live cont)
 5824        (let* ((con-lbl (bbs-new-lbl! *bbs*)) (alt-lbl (bbs-new-lbl! *bbs*)))
 5825          (save-opnd-to-reg
 5826           (gen-node pre live 'need)
 5827           target.proc-result
 5828           predicate-var
 5829           live
 5830           (source-comment pre))
 5831          (seal-bb (intrs-enabled? (node-decl node)) 'internal)
 5832          (bb-put-branch!
 5833           *bb*
 5834           (make-ifjump
 5835            **not-proc-obj
 5836            (list target.proc-result)
 5837            alt-lbl
 5838            con-lbl
 5839            #f
 5840            (current-frame (set-adjoin live predicate-var))
 5841            (source-comment node)))
 5842          (cont con-lbl alt-lbl)))
 5843      (define (alternative con-lbl alt-lbl)
 5844        (let* ((pre-context (current-context))
 5845               (result-var (make-temp-var 'result))
 5846               (con-live (if bool? live (set-adjoin live predicate-var)))
 5847               (alt-live (set-union live (free-variables alt)))
 5848               (con-bb (make-bb (make-label-simple
 5849                                 con-lbl
 5850                                 (current-frame con-live)
 5851                                 (source-comment alt))
 5852                                *bbs*))
 5853               (alt-bb (make-bb (make-label-simple
 5854                                 alt-lbl
 5855                                 (current-frame alt-live)
 5856                                 (source-comment alt))
 5857                                *bbs*)))
 5858          (if bool?
 5859              (begin
 5860                (set! *bb* con-bb)
 5861                (save-opnd-to-reg
 5862                 (make-obj (if (conj? node) false-object #t))
 5863                 target.proc-result
 5864                 result-var
 5865                 live
 5866                 (source-comment node)))
 5867              (put-var (var->opnd predicate-var) result-var))
 5868          (let ((con-context (current-context)))
 5869            (set! *bb* alt-bb)
 5870            (restore-context pre-context)
 5871            (let ((alt-opnd (gen-node alt live why)))
 5872              (if (eq? why 'tail)
 5873                  (begin
 5874                    (restore-context con-context)
 5875                    (set! *bb* con-bb)
 5876                    (let ((ret-opnd (var->opnd ret-var))
 5877                          (result-set (set-singleton result-var)))
 5878                      (seal-bb (intrs-enabled? (node-decl node)) 'return)
 5879                      (dealloc-slots nb-slots)
 5880                      (bb-put-branch!
 5881                       *bb*
 5882                       (make-jump
 5883                        ret-opnd
 5884                        #f
 5885                        #f
 5886                        (current-frame result-set)
 5887                        #f))))
 5888                  (let ((alt-context* (current-context)) (alt-bb* *bb*))
 5889                    (restore-context con-context)
 5890                    (set! *bb* con-bb)
 5891                    (seal-bb (intrs-enabled? (node-decl node)) 'internal)
 5892                    (let ((con-context* (current-context))
 5893                          (next-lbl (bbs-new-lbl! *bbs*)))
 5894                      (restore-context alt-context*)
 5895                      (set! *bb* alt-bb*)
 5896                      (save-opnd-to-reg
 5897                       alt-opnd
 5898                       target.proc-result
 5899                       result-var
 5900                       live
 5901                       (source-comment alt))
 5902                      (merge-contexts-and-seal-bb
 5903                       con-context*
 5904                       (set-adjoin live result-var)
 5905                       (intrs-enabled? (node-decl node))
 5906                       'internal
 5907                       (source-comment node))
 5908                      (let ((frame (current-frame
 5909                                    (set-adjoin live result-var))))
 5910                        (bb-put-branch!
 5911                         *bb*
 5912                         (make-jump (make-lbl next-lbl) #f #f frame #f))
 5913                        (bb-put-branch!
 5914                         con-bb
 5915                         (make-jump (make-lbl next-lbl) #f #f frame #f))
 5916                        (set! *bb*
 5917                              (make-bb (make-label-simple
 5918                                        next-lbl
 5919                                        frame
 5920                                        (source-comment node))
 5921                                       *bbs*))
 5922                        target.proc-result))))))))
 5923      ((if bool? predicate general-predicate)
 5924       pre
 5925       needed
 5926       (lambda (true-lbl false-lbl)
 5927         (if (conj? node)
 5928             (alternative false-lbl true-lbl)
 5929             (alternative true-lbl false-lbl)))))))
 5930(define (gen-call node live why)
 5931  (let* ((oper (app-oper node)) (args (app-args node)) (nb-args (length args)))
 5932    (if (and (prc? oper)
 5933             (not (prc-rest oper))
 5934             (= (length (prc-parms oper)) nb-args))
 5935        (gen-let (prc-parms oper) args (prc-body oper) live why)
 5936        (if (inlinable-app? node)
 5937            (let ((eval-order (arg-eval-order #f args))
 5938                  (vars (map (lambda (x) (cons x #f)) args)))
 5939              (let loop ((l eval-order) (liv live))
 5940                (if (not (null? l))
 5941                    (let* ((needed (vals-live-vars liv (map car (cdr l))))
 5942                           (arg (car (car l)))
 5943                           (pos (cdr (car l)))
 5944                           (var (save-var
 5945                                 (gen-node arg needed 'need)
 5946                                 (make-temp-var pos)
 5947                                 needed
 5948                                 (source-comment arg))))
 5949                      (set-cdr! (assq arg vars) var)
 5950                      (loop (cdr l) (set-adjoin liv var)))
 5951                    (let ((loc (if (eq? why 'side)
 5952                                   (make-reg 0)
 5953                                   (or (lowest-dead-reg live)
 5954                                       (lowest-dead-slot live)))))
 5955                      (if (and (stk? loc) (> (stk-num loc) nb-slots))
 5956                          (push-slot))
 5957                      (let* ((args (map var->opnd (map cdr vars)))
 5958                             (var (make-temp-var 'result))
 5959                             (proc (node->proc oper))
 5960                             (strict-pat (proc-obj-strict-pat proc)))
 5961                        (if (not (eq? why 'side)) (put-var loc var))
 5962                        (bb-put-non-branch!
 5963                         *bb*
 5964                         (make-apply
 5965                          (specialize-for-call proc (node-decl node))
 5966                          args
 5967                          (if (eq? why 'side) #f loc)
 5968                          (current-frame
 5969                           (if (eq? why 'side) live (set-adjoin live var)))
 5970                          (source-comment node)))
 5971                        (gen-return loc why node))))))
 5972            (let* ((calling-local-proc?
 5973                    (and (ref? oper)
 5974                         (let ((opnd (var->opnd (ref-var oper))))
 5975                           (and (lbl? opnd)
 5976                                (let ((x (assq (lbl-num opnd) known-procs)))
 5977                                  (and x
 5978                                       (let ((proc (cdr x)))
 5979                                         (and (not (prc-rest proc))
 5980                                              (= (prc-min proc) nb-args)
 5981                                              (= (length (prc-parms proc))
 5982                                                 nb-args)
 5983                                              (lbl-num opnd)))))))))
 5984                   (jstate (get-jump-state
 5985                            args
 5986                            (if calling-local-proc?
 5987                                (target.label-info nb-args nb-args #f #f)
 5988                                (target.jump-info nb-args))))
 5989                   (in-stk (jump-state-in-stk jstate))
 5990                   (in-reg (jump-state-in-reg jstate))
 5991                   (eval-order
 5992                    (arg-eval-order (if calling-local-proc? #f oper) in-reg))
 5993                   (live-after
 5994                    (if (eq? why 'tail) (set-remove live ret-var) live))
 5995                   (live-for-regs (args-live-vars live eval-order))
 5996                   (return-lbl (if (eq? why 'tail) #f (bbs-new-lbl! *bbs*))))
 5997              (save-regs
 5998               (live-regs live-after)
 5999               (stk-live-vars live-for-regs in-stk why)
 6000               (source-comment node))
 6001              (let ((frame-start (stk-num (highest-live-slot live-after))))
 6002                (let loop1 ((l in-stk) (liv live-after) (i (+ frame-start 1)))
 6003                  (if (not (null? l))
 6004                      (let ((arg (car l))
 6005                            (slot (make-stk i))
 6006                            (needed (set-union
 6007                                     (stk-live-vars liv (cdr l) why)
 6008                                     live-for-regs)))
 6009                        (if arg
 6010                            (let ((var (if (and (eq? arg 'return)
 6011                                                (eq? why 'tail))
 6012                                           ret-var
 6013                                           (make-temp-var (- frame-start i)))))
 6014                              (save-opnd-to-stk
 6015                               (if (eq? arg 'return)
 6016                                   (if (eq? why 'tail)
 6017                                       (var->opnd ret-var)
 6018                                       (make-lbl return-lbl))
 6019                                   (gen-node arg needed 'need))
 6020                               slot
 6021                               var
 6022                               needed
 6023                               (source-comment
 6024                                (if (eq? arg 'return) node arg)))
 6025                              (loop1 (cdr l) (set-adjoin liv var) (+ i 1)))
 6026                            (begin
 6027                              (if (> i nb-slots)
 6028                                  (put-copy
 6029                                   (make-obj undef-object)
 6030                                   slot
 6031                                   empty-var
 6032                                   liv
 6033                                   (source-comment node)))
 6034                              (loop1 (cdr l) liv (+ i 1)))))
 6035                      (let loop2 ((l eval-order)
 6036                                  (liv liv)
 6037                                  (reg-map '())
 6038                                  (oper-var '()))
 6039                        (if (not (null? l))
 6040                            (let* ((arg (car (car l)))
 6041                                   (pos (cdr (car l)))
 6042                                   (needed (args-live-vars liv (cdr l)))
 6043                                   (var (if (and (eq? arg 'return)
 6044                                                 (eq? why 'tail))
 6045                                            ret-var
 6046                                            (make-temp-var pos)))
 6047                                   (opnd (if (eq? arg 'return)
 6048                                             (if (eq? why 'tail)
 6049                                                 (var->opnd ret-var)
 6050                                                 (make-lbl return-lbl))
 6051                                             (gen-node arg needed 'need))))
 6052                              (if (eq? pos 'operator)
 6053                                  (if (and (ref? arg)
 6054                                           (not (or (obj? opnd) (lbl? opnd))))
 6055                                      (loop2 (cdr l)
 6056                                             (set-adjoin liv (ref-var arg))
 6057                                             reg-map
 6058                                             (ref-var arg))
 6059                                      (begin
 6060                                        (save-arg
 6061                                         opnd
 6062                                         var
 6063                                         needed
 6064                                         (source-comment
 6065                                          (if (eq? arg 'return) node arg)))
 6066                                        (loop2 (cdr l)
 6067                                               (set-adjoin liv var)
 6068                                               reg-map
 6069                                               var)))
 6070                                  (let ((reg (make-reg pos)))
 6071                                    (if (all-args-trivial? (cdr l))
 6072                                        (save-opnd-to-reg
 6073                                         opnd
 6074                                         reg
 6075                                         var
 6076                                         needed
 6077                                         (source-comment
 6078                                          (if (eq? arg 'return) node arg)))
 6079                                        (save-in-slot
 6080                                         opnd
 6081                                         var
 6082                                         needed
 6083                                         (source-comment
 6084                                          (if (eq? arg 'return) node arg))))
 6085                                    (loop2 (cdr l)
 6086                                           (set-adjoin liv var)
 6087                                           (cons (cons pos var) reg-map)
 6088                                           oper-var))))
 6089                            (let loop3 ((i (- target.nb-regs 1)))
 6090                              (if (>= i 0)
 6091                                  (let ((couple (assq i reg-map)))
 6092                                    (if couple
 6093                                        (let ((var (cdr couple)))
 6094                                          (if (not (eq? (reg->var regs i) var))
 6095                                              (save-opnd-to-reg
 6096                                               (var->opnd var)
 6097                                               (make-reg i)
 6098                                               var
 6099                                               liv
 6100                                               (source-comment node)))))
 6101                                    (loop3 (- i 1)))
 6102                                  (let ((opnd (if calling-local-proc?
 6103                                                  (make-lbl
 6104                                                   (+ calling-local-proc? 1))
 6105                                                  (var->opnd oper-var))))
 6106                                    (seal-bb (intrs-enabled? (node-decl node))
 6107                                             (if return-lbl 'call 'tail-call))
 6108                                    (dealloc-slots
 6109                                     (- nb-slots
 6110                                        (+ frame-start (length in-stk))))
 6111                                    (bb-put-branch!
 6112                                     *bb*
 6113                                     (make-jump
 6114                                      opnd
 6115                                      (if calling-local-proc? #f nb-args)
 6116                                      #f
 6117                                      (current-frame liv)
 6118                                      (source-comment node)))
 6119                                    (let ((result-var (make-temp-var 'result)))
 6120                                      (dealloc-slots (- nb-slots frame-start))
 6121                                      (flush-regs)
 6122                                      (put-var target.proc-result result-var)
 6123                                      (if return-lbl
 6124                                          (begin
 6125                                            (set! poll (return-poll poll))
 6126                                            (set! *bb*
 6127                                                  (make-bb (make-label-return
 6128                                                            return-lbl
 6129                                                            (current-frame
 6130                                                             (set-adjoin
 6131                                                              live
 6132                                                              result-var))
 6133                                                            (source-comment
 6134                                                             node))
 6135                                                           *bbs*))))
 6136                                      target.proc-result))))))))))))))
 6137(define (contained-reg/slot opnd)
 6138  (cond ((reg? opnd) opnd)
 6139        ((stk? opnd) opnd)
 6140        ((clo? opnd) (contained-reg/slot (clo-base opnd)))
 6141        (else #f)))
 6142(define (opnd-needed opnd needed)
 6143  (let ((x (contained-reg/slot opnd)))
 6144    (if x (set-adjoin needed (get-var x)) needed)))
 6145(define (save-opnd opnd live comment)
 6146  (let ((slot (lowest-dead-slot live)))
 6147    (put-copy opnd slot (get-var opnd) live comment)))
 6148(define (save-regs regs live comment)
 6149  (for-each
 6150   (lambda (i) (save-opnd (make-reg i) live comment))
 6151   (set->list regs)))
 6152(define (save-opnd-to-reg opnd reg var live comment)
 6153  (if (set-member? (reg-num reg) (live-regs live))
 6154      (save-opnd reg (opnd-needed opnd live) comment))
 6155  (put-copy opnd reg var live comment))
 6156(define (save-opnd-to-stk opnd stk var live comment)
 6157  (if (set-member? (stk-num stk) (live-slots live))
 6158      (save-opnd stk (opnd-needed opnd live) comment))
 6159  (put-copy opnd stk var live comment))
 6160(define (all-args-trivial? l)
 6161  (if (null? l)
 6162      #t
 6163      (let ((arg (car (car l))))
 6164        (or (eq? arg 'return)
 6165            (and (trivial? arg) (all-args-trivial? (cdr l)))))))
 6166(define (every-trivial? l)
 6167  (or (null? l) (and (trivial? (car l)) (every-trivial? (cdr l)))))
 6168(define (trivial? node)
 6169  (or (cst? node)
 6170      (ref? node)
 6171      (and (set? node) (trivial? (set-val node)))
 6172      (and (inlinable-app? node) (every-trivial? (app-args node)))))
 6173(define (inlinable-app? node)
 6174  (if (app? node)
 6175      (let ((proc (node->proc (app-oper node))))
 6176        (and proc
 6177             (let ((spec (specialize-for-call proc (node-decl node))))
 6178               (and (proc-obj-inlinable spec)
 6179                    (nb-args-conforms?
 6180                     (length (app-args node))
 6181                     (proc-obj-call-pat spec))))))
 6182      #f))
 6183(define (boolean-value? node)
 6184  (or (and (conj? node)
 6185           (boolean-value? (conj-pre node))
 6186           (boolean-value? (conj-alt node)))
 6187      (and (disj? node)
 6188           (boolean-value? (disj-pre node))
 6189           (boolean-value? (disj-alt node)))
 6190      (boolean-app? node)))
 6191(define (boolean-app? node)
 6192  (if (app? node)
 6193      (let ((proc (node->proc (app-oper node))))
 6194        (if proc (eq? (type-name (proc-obj-type proc)) 'boolean) #f))
 6195      #f))
 6196(define (node->proc node)
 6197  (cond ((cst? node) (if (proc-obj? (cst-val node)) (cst-val node) #f))
 6198        ((ref? node)
 6199         (if (global? (ref-var node))
 6200             (target.prim-info* (var-name (ref-var node)) (node-decl node))
 6201             #f))
 6202        (else #f)))
 6203(define (specialize-for-call proc decl) ((proc-obj-specialize proc) decl))
 6204(define (get-jump-state args pc)
 6205  (define (empty-node-list n)
 6206    (if (> n 0) (cons #f (empty-node-list (- n 1))) '()))
 6207  (let* ((fs (pcontext-fs pc))
 6208         (slots-list (empty-node-list fs))
 6209         (regs-list (empty-node-list target.nb-regs)))
 6210    (define (assign-node-to-loc var loc)
 6211      (let ((x (cond ((reg? loc)
 6212                      (let ((i (reg-num loc)))
 6213                        (if (<= i target.nb-regs)
 6214                            (nth-after regs-list i)
 6215                            (compiler-internal-error
 6216                             "jump-state, reg out of bound in back-end's pcontext"))))
 6217                     ((stk? loc)
 6218                      (let ((i (stk-num loc)))
 6219                        (if (<= i fs)
 6220                            (nth-after slots-list (- i 1))
 6221                            (compiler-internal-error
 6222                             "jump-state, stk out of bound in back-end's pcontext"))))
 6223                     (else
 6224                      (compiler-internal-error
 6225                       "jump-state, loc other than reg or stk in back-end's pcontext")))))
 6226        (if (not (car x))
 6227            (set-car! x var)
 6228            (compiler-internal-error
 6229             "jump-state, duplicate location in back-end's pcontext"))))
 6230    (let loop ((l (pcontext-map pc)))
 6231      (if (not (null? l))
 6232          (let* ((couple (car l)) (name (car couple)) (loc (cdr couple)))
 6233            (cond ((eq? name 'return) (assign-node-to-loc 'return loc))
 6234                  (else (assign-node-to-loc (list-ref args (- name 1)) loc)))
 6235            (loop (cdr l)))))
 6236    (vector slots-list regs-list)))
 6237(define (jump-state-in-stk x) (vector-ref x 0))
 6238(define (jump-state-in-reg x) (vector-ref x 1))
 6239(define (arg-eval-order oper nodes)
 6240  (define (loop nodes pos part1 part2)
 6241    (cond ((null? nodes)
 6242           (let ((p1 (reverse part1)) (p2 (free-vars-order part2)))
 6243             (cond ((not oper) (append p1 p2))
 6244                   ((trivial? oper)
 6245                    (append p1 p2 (list (cons oper 'operator))))
 6246                   (else (append (cons (cons oper 'operator) p1) p2)))))
 6247          ((not (car nodes)) (loop (cdr nodes) (+ pos 1) part1 part2))
 6248          ((or (eq? (car nodes) 'return) (trivial? (car nodes)))
 6249           (loop (cdr nodes)
 6250                 (+ pos 1)
 6251                 part1
 6252                 (cons (cons (car nodes) pos) part2)))
 6253          (else
 6254           (loop (cdr nodes)
 6255                 (+ pos 1)
 6256                 (cons (cons (car nodes) pos) part1)
 6257                 part2))))
 6258  (loop nodes 0 '() '()))
 6259(define (free-vars-order l)
 6260  (let ((bins '()) (ordered-args '()))
 6261    (define (free-v x) (if (eq? x 'return) (set-empty) (free-variables x)))
 6262    (define (add-to-bin! x)
 6263      (let ((y (assq x bins)))
 6264        (if y (set-cdr! y (+ (cdr y) 1)) (set! bins (cons (cons x 1) bins)))))
 6265    (define (payoff-if-removed node)
 6266      (let ((x (free-v node)))
 6267        (let loop ((l (set->list x)) (r 0))
 6268          (if (null? l)
 6269              r
 6270              (let ((y (cdr (assq (car l) bins))))
 6271                (loop (cdr l) (+ r (quotient 1000 (* y y)))))))))
 6272    (define (remove-free-vars! x)
 6273      (let loop ((l (set->list x)))
 6274        (if (not (null? l))
 6275            (let ((y (assq (car l) bins)))
 6276              (set-cdr! y (- (cdr y) 1))
 6277              (loop (cdr l))))))
 6278    (define (find-max-payoff l thunk)
 6279      (if (null? l)
 6280          (thunk '() -1)
 6281          (find-max-payoff
 6282           (cdr l)
 6283           (lambda (best-arg best-payoff)
 6284             (let ((payoff (payoff-if-removed (car (car l)))))
 6285               (if (>= payoff best-payoff)
 6286                   (thunk (car l) payoff)
 6287                   (thunk best-arg best-payoff)))))))
 6288    (define (remove x l)
 6289      (cond ((null? l) '())
 6290            ((eq? x (car l)) (cdr l))
 6291            (else (cons (car l) (remove x (cdr l))))))
 6292    (for-each
 6293     (lambda (x) (for-each add-to-bin! (set->list (free-v (car x)))))
 6294     l)
 6295    (let loop ((args l) (ordered-args '()))
 6296      (if (null? args)
 6297          (reverse ordered-args)
 6298          (find-max-payoff
 6299           args
 6300           (lambda (best-arg best-payoff)
 6301             (remove-free-vars! (free-v (car best-arg)))
 6302             (loop (remove best-arg args) (cons best-arg ordered-args))))))))
 6303(define (args-live-vars live order)
 6304  (cond ((null? order) live)
 6305        ((eq? (car (car order)) 'return)
 6306         (args-live-vars (set-adjoin live ret-var) (cdr order)))
 6307        (else
 6308         (args-live-vars
 6309          (set-union live (free-variables (car (car order))))
 6310          (cdr order)))))
 6311(define (stk-live-vars live slots why)
 6312  (cond ((null? slots) live)
 6313        ((not (car slots)) (stk-live-vars live (cdr slots) why))
 6314        ((eq? (car slots) 'return)
 6315         (stk-live-vars
 6316          (if (eq? why 'tail) (set-adjoin live ret-var) live)
 6317          (cdr slots)
 6318          why))
 6319        (else
 6320         (stk-live-vars
 6321          (set-union live (free-variables (car slots)))
 6322          (cdr slots)
 6323          why))))
 6324(define (gen-let vars vals node live why)
 6325  (let ((var-val-map (pair-up vars vals))
 6326        (var-set (list->set vars))
 6327        (all-live
 6328         (set-union
 6329          live
 6330          (free-variables node)
 6331          (apply set-union (map free-variables vals)))))
 6332    (define (var->val var) (cdr (assq var var-val-map)))
 6333    (define (proc-var? var) (prc? (var->val var)))
 6334    (define (closed-vars var const-proc-vars)
 6335      (set-difference
 6336       (not-constant-closed-vars (var->val var))
 6337       const-proc-vars))
 6338    (define (no-closed-vars? var const-proc-vars)
 6339      (set-empty? (closed-vars var const-proc-vars)))
 6340    (define (closed-vars? var const-proc-vars)
 6341      (not (no-closed-vars? var const-proc-vars)))
 6342    (define (compute-const-proc-vars proc-vars)
 6343      (let loop1 ((const-proc-vars proc-vars))
 6344        (let ((new-const-proc-vars
 6345               (set-keep
 6346                (lambda (x) (no-closed-vars? x const-proc-vars))
 6347                const-proc-vars)))
 6348          (if (not (set-equal? new-const-proc-vars const-proc-vars))
 6349              (loop1 new-const-proc-vars)
 6350              const-proc-vars))))
 6351    (let* ((proc-vars (set-keep proc-var? var-set))
 6352           (const-proc-vars (compute-const-proc-vars proc-vars))
 6353           (clo-vars
 6354            (set-keep (lambda (x) (closed-vars? x const-proc-vars)) proc-vars))
 6355           (clo-vars-list (set->list clo-vars)))
 6356      (for-each
 6357       (lambda (proc-var)
 6358         (let ((label (schedule-gen-proc (var->val proc-var) '())))
 6359           (add-known-proc (lbl-num label) (var->val proc-var))
 6360           (add-constant-var proc-var label)))
 6361       (set->list const-proc-vars))
 6362      (let ((non-clo-vars-list
 6363             (set->list
 6364              (set-keep
 6365               (lambda (var)
 6366                 (and (not (set-member? var const-proc-vars))
 6367                      (not (set-member? var clo-vars))))
 6368               vars)))
 6369            (liv (set-union
 6370                  live
 6371                  (apply set-union
 6372                         (map (lambda (x) (closed-vars x const-proc-vars))
 6373                              clo-vars-list))
 6374                  (free-variables node))))
 6375        (let loop2 ((vars* non-clo-vars-list))
 6376          (if (not (null? vars*))
 6377              (let* ((var (car vars*))
 6378                     (val (var->val var))
 6379                     (needed (vals-live-vars liv (map var->val (cdr vars*)))))
 6380                (if (var-useless? var)
 6381                    (gen-node val needed 'side)
 6382                    (save-val
 6383                     (gen-node val needed 'need)
 6384                     var
 6385                     needed
 6386                     (source-comment val)))
 6387                (loop2 (cdr vars*)))))
 6388        (if (pair? clo-vars-list)
 6389            (begin
 6390              (dealloc-slots (- nb-slots (stk-num (highest-live-slot liv))))
 6391              (let loop3 ((l clo-vars-list))
 6392                (if (not (null? l))
 6393                    (begin
 6394                      (push-slot)
 6395                      (let ((var (car l)) (slot (make-stk nb-slots)))
 6396                        (put-var slot var)
 6397                        (loop3 (cdr l))))))
 6398              (bb-put-non-branch!
 6399               *bb*
 6400               (make-close
 6401                (map (lambda (var)
 6402                       (let ((closed-list
 6403                              (sort-variables
 6404                               (set->list (closed-vars var const-proc-vars)))))
 6405                         (if (null? closed-list)
 6406                             (compiler-internal-error
 6407                              "gen-let, no closed variables:"
 6408                              (var-name var))
 6409                             (make-closure-parms
 6410                              (var->opnd var)
 6411                              (lbl-num (schedule-gen-proc
 6412                                        (var->val var)
 6413                                        closed-list))
 6414                              (map var->opnd closed-list)))))
 6415                     clo-vars-list)
 6416                (current-frame liv)
 6417                (source-comment node)))))
 6418        (gen-node node live why)))))
 6419(define (save-arg opnd var live comment)
 6420  (if (glo? opnd)
 6421      (add-constant-var var opnd)
 6422      (save-val opnd var live comment)))
 6423(define (save-val opnd var live comment)
 6424  (cond ((or (obj? opnd) (lbl? opnd)) (add-constant-var var opnd))
 6425        ((and (reg? opnd) (not (set-member? (reg-num opnd) (live-regs live))))
 6426         (put-var opnd var))
 6427        ((and (stk? opnd) (not (set-member? (stk-num opnd) (live-slots live))))
 6428         (put-var opnd var))
 6429        (else (save-in-slot opnd var live comment))))
 6430(define (save-in-slot opnd var live comment)
 6431  (let ((slot (lowest-dead-slot live))) (put-copy opnd slot var live comment)))
 6432(define (save-var opnd var live comment)
 6433  (cond ((or (obj? opnd) (lbl? opnd)) (add-constant-var var opnd) var)
 6434        ((or (glo? opnd) (reg? opnd) (stk? opnd)) (get-var opnd))
 6435        (else
 6436         (let ((dest (or (highest-dead-reg live) (lowest-dead-slot live))))
 6437           (put-copy opnd dest var live comment)
 6438           var))))
 6439(define (put-copy opnd loc var live comment)
 6440  (if (and (stk? loc) (> (stk-num loc) nb-slots)) (push-slot))
 6441  (if var (put-var loc var))
 6442  (if (not (eq? opnd loc))
 6443      (bb-put-non-branch!
 6444       *bb*
 6445       (make-copy
 6446        opnd
 6447        loc
 6448        (current-frame (if var (set-adjoin live var) live))
 6449        comment))))
 6450(define (var-useless? var)
 6451  (and (set-empty? (var-refs var)) (set-empty? (var-sets var))))
 6452(define (vals-live-vars live vals)
 6453  (if (null? vals)
 6454      live
 6455      (vals-live-vars
 6456       (set-union live (free-variables (car vals)))
 6457       (cdr vals))))
 6458(define (gen-fut node live why)
 6459  (let* ((val (fut-val node))
 6460         (clo-vars (not-constant-closed-vars val))
 6461         (clo-vars-list (set->list clo-vars))
 6462         (ret-var* (make-temp-var 0))
 6463         (live-after live)
 6464         (live-starting-task
 6465          (set-adjoin (set-union live-after clo-vars) ret-var*))
 6466         (task-lbl (bbs-new-lbl! *bbs*))
 6467         (return-lbl (bbs-new-lbl! *bbs*)))
 6468    (save-regs (live-regs live-after) live-starting-task (source-comment node))
 6469    (let ((frame-start (stk-num (highest-live-slot live-after))))
 6470      (save-opnd-to-reg
 6471       (make-lbl return-lbl)
 6472       target.task-return
 6473       ret-var*
 6474       (set-remove live-starting-task ret-var*)
 6475       (source-comment node))
 6476      (let loop1 ((l clo-vars-list) (i 0))
 6477        (if (null? l)
 6478            (dealloc-slots (- nb-slots (+ frame-start i)))
 6479            (let ((var (car l)) (rest (cdr l)))
 6480              (if (memq var regs)
 6481                  (loop1 rest i)
 6482                  (let loop2 ((j (- target.nb-regs 1)))
 6483                    (if (>= j 0)
 6484                        (if (or (>= j (length regs))
 6485                                (not (set-member?
 6486                                      (list-ref regs j)
 6487                                      live-starting-task)))
 6488                            (let ((reg (make-reg j)))
 6489                              (put-copy
 6490                               (var->opnd var)
 6491                               reg
 6492                               var
 6493                               live-starting-task
 6494                               (source-comment node))
 6495                              (loop1 rest i))
 6496                            (loop2 (- j 1)))
 6497                        (let ((slot (make-stk (+ frame-start (+ i 1))))
 6498                              (needed (list->set rest)))
 6499                          (if (and (or (> (stk-num slot) nb-slots)
 6500                                       (not (memq (list-ref
 6501                                                   slots
 6502                                                   (- nb-slots (stk-num slot)))
 6503                                                  regs)))
 6504                                   (set-member?
 6505                                    (stk-num slot)
 6506                                    (live-slots needed)))
 6507                              (save-opnd
 6508                               slot
 6509                               live-starting-task
 6510                               (source-comment node)))
 6511                          (put-copy
 6512                           (var->opnd var)
 6513                           slot
 6514                           var
 6515                           live-starting-task
 6516                           (source-comment node))
 6517                          (loop1 rest (+ i 1)))))))))
 6518      (seal-bb (intrs-enabled? (node-decl node)) 'call)
 6519      (bb-put-branch!
 6520       *bb*
 6521       (make-jump
 6522        (make-lbl task-lbl)
 6523        #f
 6524        #f
 6525        (current-frame live-starting-task)
 6526        #f))
 6527      (let ((task-context
 6528             (make-context
 6529              (- nb-slots frame-start)
 6530              (reverse (nth-after (reverse slots) frame-start))
 6531              (cons ret-var (cdr regs))
 6532              '()
 6533              poll
 6534              entry-bb))
 6535            (return-context
 6536             (make-context
 6537              frame-start
 6538              (nth-after slots (- nb-slots frame-start))
 6539              '()
 6540              closed
 6541              (return-poll poll)
 6542              entry-bb)))
 6543        (restore-context task-context)
 6544        (set! *bb*
 6545              (make-bb (make-label-task-entry
 6546                        task-lbl
 6547                        (current-frame live-starting-task)
 6548                        (source-comment node))
 6549                       *bbs*))
 6550        (gen-node val ret-var-set 'tail)
 6551        (let ((result-var (make-temp-var 'future)))
 6552          (restore-context return-context)
 6553          (put-var target.proc-result result-var)
 6554          (set! *bb*
 6555                (make-bb (make-label-task-return
 6556                          return-lbl
 6557                          (current-frame (set-adjoin live result-var))
 6558                          (source-comment node))
 6559                         *bbs*))
 6560          (gen-return target.proc-result why node))))))
 6561(define prim-procs
 6562  '(("not" (1) #f 0 boolean)
 6563    ("boolean?" (1) #f 0 boolean)
 6564    ("eqv?" (2) #f 0 boolean)
 6565    ("eq?" (2) #f 0 boolean)
 6566    ("equal?" (2) #f 0 boolean)
 6567    ("pair?" (1) #f 0 boolean)
 6568    ("cons" (2) #f () pair)
 6569    ("car" (1) #f 0 (#f))
 6570    ("cdr" (1) #f 0 (#f))
 6571    ("set-car!" (2) #t (1) pair)
 6572    ("set-cdr!" (2) #t (1) pair)
 6573    ("caar" (1) #f 0 (#f))
 6574    ("cadr" (1) #f 0 (#f))
 6575    ("cdar" (1) #f 0 (#f))
 6576    ("cddr" (1) #f 0 (#f))
 6577    ("caaar" (1) #f 0 (#f))
 6578    ("caadr" (1) #f 0 (#f))
 6579    ("cadar" (1) #f 0 (#f))
 6580    ("caddr" (1) #f 0 (#f))
 6581    ("cdaar" (1) #f 0 (#f))
 6582    ("cdadr" (1) #f 0 (#f))
 6583    ("cddar" (1) #f 0 (#f))
 6584    ("cdddr" (1) #f 0 (#f))
 6585    ("caaaar" (1) #f 0 (#f))
 6586    ("caaadr" (1) #f 0 (#f))
 6587    ("caadar" (1) #f 0 (#f))
 6588    ("caaddr" (1) #f 0 (#f))
 6589    ("cadaar" (1) #f 0 (#f))
 6590    ("cadadr" (1) #f 0 (#f))
 6591    ("caddar" (1) #f 0 (#f))
 6592    ("cadddr" (1) #f 0 (#f))
 6593    ("cdaaar" (1) #f 0 (#f))
 6594    ("cdaadr" (1) #f 0 (#f))
 6595    ("cdadar" (1) #f 0 (#f))
 6596    ("cdaddr" (1) #f 0 (#f))
 6597    ("cddaar" (1) #f 0 (#f))
 6598    ("cddadr" (1) #f 0 (#f))
 6599    ("cdddar" (1) #f 0 (#f))
 6600    ("cddddr" (1) #f 0 (#f))
 6601    ("null?" (1) #f 0 boolean)
 6602    ("list?" (1) #f 0 boolean)
 6603    ("list" 0 #f () list)
 6604    ("length" (1) #f 0 integer)
 6605    ("append" 0 #f 0 list)
 6606    ("reverse" (1) #f 0 list)
 6607    ("list-ref" (2) #f 0 (#f))
 6608    ("memq" (2) #f 0 list)
 6609    ("memv" (2) #f 0 list)
 6610    ("member" (2) #f 0 list)
 6611    ("assq" (2) #f 0 #f)
 6612    ("assv" (2) #f 0 #f)
 6613    ("assoc" (2) #f 0 #f)
 6614    ("symbol?" (1) #f 0 boolean)
 6615    ("symbol->string" (1) #f 0 string)
 6616    ("string->symbol" (1) #f 0 symbol)
 6617    ("number?" (1) #f 0 boolean)
 6618    ("complex?" (1) #f 0 boolean)
 6619    ("real?" (1) #f 0 boolean)
 6620    ("rational?" (1) #f 0 boolean)
 6621    ("integer?" (1) #f 0 boolean)
 6622    ("exact?" (1) #f 0 boolean)
 6623    ("inexact?" (1) #f 0 boolean)
 6624    ("=" 0 #f 0 boolean)
 6625    ("<" 0 #f 0 boolean)
 6626    (">" 0 #f 0 boolean)
 6627    ("<=" 0 #f 0 boolean)
 6628    (">=" 0 #f 0 boolean)
 6629    ("zero?" (1) #f 0 boolean)
 6630    ("positive?" (1) #f 0 boolean)
 6631    ("negative?" (1) #f 0 boolean)
 6632    ("odd?" (1) #f 0 boolean)
 6633    ("even?" (1) #f 0 boolean)
 6634    ("max" 1 #f 0 number)
 6635    ("min" 1 #f 0 number)
 6636    ("+" 0 #f 0 number)
 6637    ("*" 0 #f 0 number)
 6638    ("-" 1 #f 0 number)
 6639    ("/" 1 #f 0 number)
 6640    ("abs" (1) #f 0 number)
 6641    ("quotient" 1 #f 0 integer)
 6642    ("remainder" (2) #f 0 integer)
 6643    ("modulo" (2) #f 0 integer)
 6644    ("gcd" 1 #f 0 integer)
 6645    ("lcm" 1 #f 0 integer)
 6646    ("numerator" (1) #f 0 integer)
 6647    ("denominator" (1) #f 0 integer)
 6648    ("floor" (1) #f 0 integer)
 6649    ("ceiling" (1) #f 0 integer)
 6650    ("truncate" (1) #f 0 integer)
 6651    ("round" (1) #f 0 integer)
 6652    ("rationalize" (2) #f 0 number)
 6653    ("exp" (1) #f 0 number)
 6654    ("log" (1) #f 0 number)
 6655    ("sin" (1) #f 0 number)
 6656    ("cos" (1) #f 0 number)
 6657    ("tan" (1) #f 0 number)
 6658    ("asin" (1) #f 0 number)
 6659    ("acos" (1) #f 0 number)
 6660    ("atan" (1 2) #f 0 number)
 6661    ("sqrt" (1) #f 0 number)
 6662    ("expt" (2) #f 0 number)
 6663    ("make-rectangular" (2) #f 0 number)
 6664    ("make-polar" (2) #f 0 number)
 6665    ("real-part" (1) #f 0 real)
 6666    ("imag-part" (1) #f 0 real)
 6667    ("magnitude" (1) #f 0 real)
 6668    ("angle" (1) #f 0 real)
 6669    ("exact->inexact" (1) #f 0 number)
 6670    ("inexact->exact" (1) #f 0 number)
 6671    ("number->string" (1 2) #f 0 string)
 6672    ("string->number" (1 2) #f 0 number)
 6673    ("char?" (1) #f 0 boolean)
 6674    ("char=?" 0 #f 0 boolean)
 6675    ("char<?" 0 #f 0 boolean)
 6676    ("char>?" 0 #f 0 boolean)
 6677    ("char<=?" 0 #f 0 boolean)
 6678    ("char>=?" 0 #f 0 boolean)
 6679    ("char-ci=?" 0 #f 0 boolean)
 6680    ("char-ci<?" 0 #f 0 boolean)
 6681    ("char-ci>?" 0 #f 0 boolean)
 6682    ("char-ci<=?" 0 #f 0 boolean)
 6683    ("char-ci>=?" 0 #f 0 boolean)
 6684    ("char-alphabetic?" (1) #f 0 boolean)
 6685    ("char-numeric?" (1) #f 0 boolean)
 6686    ("char-whitespace?" (1) #f 0 boolean)
 6687    ("char-upper-case?" (1) #f 0 boolean)
 6688    ("char-lower-case?" (1) #f 0 boolean)
 6689    ("char->integer" (1) #f 0 integer)
 6690    ("integer->char" (1) #f 0 char)
 6691    ("char-upcase" (1) #f 0 char)
 6692    ("char-downcase" (1) #f 0 char)
 6693    ("string?" (1) #f 0 boolean)
 6694    ("make-string" (1 2) #f 0 string)
 6695    ("string" 0 #f 0 string)
 6696    ("string-length" (1) #f 0 integer)
 6697    ("string-ref" (2) #f 0 char)
 6698    ("string-set!" (3) #t 0 string)
 6699    ("string=?" 0 #f 0 boolean)
 6700    ("string<?" 0 #f 0 boolean)
 6701    ("string>?" 0 #f 0 boolean)
 6702    ("string<=?" 0 #f 0 boolean)
 6703    ("string>=?" 0 #f 0 boolean)
 6704    ("string-ci=?" 0 #f 0 boolean)
 6705    ("string-ci<?" 0 #f 0 boolean)
 6706    ("string-ci>?" 0 #f 0 boolean)
 6707    ("string-ci<=?" 0 #f 0 boolean)
 6708    ("string-ci>=?" 0 #f 0 boolean)
 6709    ("substring" (3) #f 0 string)
 6710    ("string-append" 0 #f 0 string)
 6711    ("vector?" (1) #f 0 boolean)
 6712    ("make-vector" (1 2) #f (1) vector)
 6713    ("vector" 0 #f () vector)
 6714    ("vector-length" (1) #f 0 integer)
 6715    ("vector-ref" (2) #f 0 (#f))
 6716    ("vector-set!" (3) #t (1 2) vector)
 6717    ("procedure?" (1) #f 0 boolean)
 6718    ("apply" 2 #t 0 (#f))
 6719    ("map" 2 #t 0 list)
 6720    ("for-each" 2 #t 0 #f)
 6721    ("call-with-current-continuation" (1) #t 0 (#f))
 6722    ("call-with-input-file" (2) #t 0 (#f))
 6723    ("call-with-output-file" (2) #t 0 (#f))
 6724    ("input-port?" (1) #f 0 boolean)
 6725    ("output-port?" (1) #f 0 boolean)
 6726    ("current-input-port" (0) #f 0 port)
 6727    ("current-output-port" (0) #f 0 port)
 6728    ("open-input-file" (1) #t 0 port)
 6729    ("open-output-file" (1) #t 0 port)
 6730    ("close-input-port" (1) #t 0 #f)
 6731    ("close-output-port" (1) #t 0 #f)
 6732    ("eof-object?" (1) #f 0 boolean)
 6733    ("read" (0 1) #t 0 #f)
 6734    ("read-char" (0 1) #t 0 #f)
 6735    ("peek-char" (0 1) #t 0 #f)
 6736    ("write" (0 1) #t 0 #f)
 6737    ("display" (0 1) #t 0 #f)
 6738    ("newline" (0 1) #t 0 #f)
 6739    ("write-char" (1 2) #t 0 #f)
 6740    ("list-tail" (2) #f 0 (#f))
 6741    ("string->list" (1) #f 0 list)
 6742    ("list->string" (1) #f 0 string)
 6743    ("string-copy" (1) #f 0 string)
 6744    ("string-fill!" (2) #t 0 string)
 6745    ("vector->list" (1) #f 0 list)
 6746    ("list->vector" (1) #f 0 vector)
 6747    ("vector-fill!" (2) #t 0 vector)
 6748    ("force" (1) #t 0 #f)
 6749    ("with-input-from-file" (2) #t 0 (#f))
 6750    ("with-output-to-file" (2) #t 0 (#f))
 6751    ("char-ready?" (0 1) #f 0 boolean)
 6752    ("load" (1) #t 0 (#f))
 6753    ("transcript-on" (1) #t 0 #f)
 6754    ("transcript-off" (0) #t 0 #f)
 6755    ("touch" (1) #t 0 #f)
 6756    ("##type" (1) #f () integer)
 6757    ("##type-cast" (2) #f () (#f))
 6758    ("##subtype" (1) #f () integer)
 6759    ("##subtype-set!" (2) #t () #f)
 6760    ("##not" (1) #f () boolean)
 6761    ("##null?" (1) #f () boolean)
 6762    ("##unassigned?" (1) #f () boolean)
 6763    ("##unbound?" (1) #f () boolean)
 6764    ("##eq?" (2) #f () boolean)
 6765    ("##fixnum?" (1) #f () boolean)
 6766    ("##flonum?" (1) #f () boolean)
 6767    ("##special?" (1) #f () boolean)
 6768    ("##pair?" (1) #f () boolean)
 6769    ("##subtyped?" (1) #f () boolean)
 6770    ("##procedure?" (1) #f () boolean)
 6771    ("##placeholder?" (1) #f () boolean)
 6772    ("##vector?" (1) #f () boolean)
 6773    ("##symbol?" (1) #f () boolean)
 6774    ("##ratnum?" (1) #f () boolean)
 6775    ("##cpxnum?" (1) #f () boolean)
 6776    ("##string?" (1) #f () boolean)
 6777    ("##bignum?" (1) #f () boolean)
 6778    ("##char?" (1) #f () boolean)
 6779    ("##closure?" (1) #f () boolean)
 6780    ("##subprocedure?" (1) #f () boolean)
 6781    ("##return-dynamic-env-bind?" (1) #f () boolean)
 6782    ("##fixnum.+" 0 #f () integer)
 6783    ("##fixnum.*" 0 #f () integer)
 6784    ("##fixnum.-" 1 #f () integer)
 6785    ("##fixnum.quotient" (2) #f () integer)
 6786    ("##fixnum.remainder" (2) #f () integer)
 6787    ("##fixnum.modulo" (2) #f () integer)
 6788    ("##fixnum.logior" 0 #f () integer)
 6789    ("##fixnum.logxor" 0 #f () integer)
 6790    ("##fixnum.logand" 0 #f () integer)
 6791    ("##fixnum.lognot" (1) #f () integer)
 6792    ("##fixnum.ash" (2) #f () integer)
 6793    ("##fixnum.lsh" (2) #f () integer)
 6794    ("##fixnum.zero?" (1) #f () boolean)
 6795    ("##fixnum.positive?" (1) #f () boolean)
 6796    ("##fixnum.negative?" (1) #f () boolean)
 6797    ("##fixnum.odd?" (1) #f () boolean)
 6798    ("##fixnum.even?" (1) #f () boolean)
 6799    ("##fixnum.=" 0 #f () boolean)
 6800    ("##fixnum.<" 0 #f () boolean)
 6801    ("##fixnum.>" 0 #f () boolean)
 6802    ("##fixnum.<=" 0 #f () boolean)
 6803    ("##fixnum.>=" 0 #f () boolean)
 6804    ("##flonum.->fixnum" (1) #f () integer)
 6805    ("##flonum.<-fixnum" (1) #f () real)
 6806    ("##flonum.+" 0 #f () real)
 6807    ("##flonum.*" 0 #f () real)
 6808    ("##flonum.-" 1 #f () real)
 6809    ("##flonum./" 1 #f () real)
 6810    ("##flonum.abs" (1) #f () real)
 6811    ("##flonum.truncate" (1) #f () real)
 6812    ("##flonum.round" (1) #f () real)
 6813    ("##flonum.exp" (1) #f () real)
 6814    ("##flonum.log" (1) #f () real)
 6815    ("##flonum.sin" (1) #f () real)
 6816    ("##flonum.cos" (1) #f () real)
 6817    ("##flonum.tan" (1) #f () real)
 6818    ("##flonum.asin" (1) #f () real)
 6819    ("##flonum.acos" (1) #f () real)
 6820    ("##flonum.atan" (1) #f () real)
 6821    ("##flonum.sqrt" (1) #f () real)
 6822    ("##flonum.zero?" (1) #f () boolean)
 6823    ("##flonum.positive?" (1) #f () boolean)
 6824    ("##flonum.negative?" (1) #f () boolean)
 6825    ("##flonum.=" 0 #f () boolean)
 6826    ("##flonum.<" 0 #f () boolean)
 6827    ("##flonum.>" 0 #f () boolean)
 6828    ("##flonum.<=" 0 #f () boolean)
 6829    ("##flonum.>=" 0 #f () boolean)
 6830    ("##char=?" 0 #f () boolean)
 6831    ("##char<?" 0 #f () boolean)
 6832    ("##char>?" 0 #f () boolean)
 6833    ("##char<=?" 0 #f () boolean)
 6834    ("##char>=?" 0 #f () boolean)
 6835    ("##cons" (2) #f () pair)
 6836    ("##set-car!" (2) #t () pair)
 6837    ("##set-cdr!" (2) #t () pair)
 6838    ("##car" (1) #f () (#f))
 6839    ("##cdr" (1) #f () (#f))
 6840    ("##caar" (1) #f () (#f))
 6841    ("##cadr" (1) #f () (#f))
 6842    ("##cdar" (1) #f () (#f))
 6843    ("##cddr" (1) #f () (#f))
 6844    ("##caaar" (1) #f () (#f))
 6845    ("##caadr" (1) #f () (#f))
 6846    ("##cadar" (1) #f () (#f))
 6847    ("##caddr" (1) #f () (#f))
 6848    ("##cdaar" (1) #f () (#f))
 6849    ("##cdadr" (1) #f () (#f))
 6850    ("##cddar" (1) #f () (#f))
 6851    ("##cdddr" (1) #f () (#f))
 6852    ("##caaaar" (1) #f () (#f))
 6853    ("##caaadr" (1) #f () (#f))
 6854    ("##caadar" (1) #f () (#f))
 6855    ("##caaddr" (1) #f () (#f))
 6856    ("##cadaar" (1) #f () (#f))
 6857    ("##cadadr" (1) #f () (#f))
 6858    ("##caddar" (1) #f () (#f))
 6859    ("##cadddr" (1) #f () (#f))
 6860    ("##cdaaar" (1) #f () (#f))
 6861    ("##cdaadr" (1) #f () (#f))
 6862    ("##cdadar" (1) #f () (#f))
 6863    ("##cdaddr" (1) #f () (#f))
 6864    ("##cddaar" (1) #f () (#f))
 6865    ("##cddadr" (1) #f () (#f))
 6866    ("##cdddar" (1) #f () (#f))
 6867    ("##cddddr" (1) #f () (#f))
 6868    ("##make-cell" (1) #f () pair)
 6869    ("##cell-ref" (1) #f () (#f))
 6870    ("##cell-set!" (2) #t () pair)
 6871    ("##vector" 0 #f () vector)
 6872    ("##make-vector" (2) #f () vector)
 6873    ("##vector-length" (1) #f () integer)
 6874    ("##vector-ref" (2) #f () (#f))
 6875    ("##vector-set!" (3) #t () vector)
 6876    ("##vector-shrink!" (2) #t () vector)
 6877    ("##string" 0 #f () string)
 6878    ("##make-string" (2) #f () string)
 6879    ("##string-length" (1) #f () integer)
 6880    ("##string-ref" (2) #f () char)
 6881    ("##string-set!" (3) #t () string)
 6882    ("##string-shrink!" (2) #t () string)
 6883    ("##vector8" 0 #f () string)
 6884    ("##make-vector8" (2) #f () string)
 6885    ("##vector8-length" (1) #f () integer)
 6886    ("##vector8-ref" (2) #f () integer)
 6887    ("##vector8-set!" (3) #t () string)
 6888    ("##vector8-shrink!" (2) #t () string)
 6889    ("##vector16" 0 #f () string)
 6890    ("##make-vector16" (2) #f () string)
 6891    ("##vector16-length" (1) #f () integer)
 6892    ("##vector16-ref" (2) #f () integer)
 6893    ("##vector16-set!" (3) #t () string)
 6894    ("##vector16-shrink!" (2) #t () string)
 6895    ("##closure-code" (1) #f () #f)
 6896    ("##closure-ref" (2) #f () (#f))
 6897    ("##closure-set!" (3) #t () #f)
 6898    ("##subprocedure-id" (1) #f () #f)
 6899    ("##subprocedure-parent" (1) #f () #f)
 6900    ("##return-fs" (1) #f () #f)
 6901    ("##return-link" (1) #f () #f)
 6902    ("##procedure-info" (1) #f () #f)
 6903    ("##pstate" (0) #f () #f)
 6904    ("##make-placeholder" (1) #f 0 (#f))
 6905    ("##touch" (1) #t 0 #f)
 6906    ("##apply" (2) #t () (#f))
 6907    ("##call-with-current-continuation" (1) #t () (#f))
 6908    ("##global-var" (1) #t () #f)
 6909    ("##global-var-ref" (1) #f () (#f))
 6910    ("##global-var-set!" (2) #t () #f)
 6911    ("##atomic-car" (1) #f () (#f))
 6912    ("##atomic-cdr" (1) #f () (#f))
 6913    ("##atomic-set-car!" (2) #t () pair)
 6914    ("##atomic-set-cdr!" (2) #t () pair)
 6915    ("##atomic-set-car-if-eq?!" (3) #t () boolean)
 6916    ("##atomic-set-cdr-if-eq?!" (3) #t () boolean)
 6917    ("##quasi-append" 0 #f 0 list)
 6918    ("##quasi-list" 0 #f () list)
 6919    ("##quasi-cons" (2) #f () pair)
 6920    ("##quasi-list->vector" (1) #f 0 vector)
 6921    ("##case-memv" (2) #f 0 list)))
 6922(define ofile-version-major 5)
 6923(define ofile-version-minor 0)
 6924(define prim-proc-prefix 1)
 6925(define user-proc-prefix 2)
 6926(define pair-prefix 3)
 6927(define flonum-prefix 4)
 6928(define local-object-bits -524281)
 6929(define symbol-object-bits -393209)
 6930(define prim-proc-object-bits -262137)
 6931(define padding-tag 0)
 6932(define end-of-code-tag 32768)
 6933(define m68020-proc-code-tag 32769)
 6934(define m68881-proc-code-tag 32770)
 6935(define stat-tag 32771)
 6936(define global-var-ref-tag 34816)
 6937(define global-var-set-tag 36864)
 6938(define global-var-ref-jump-tag 38912)
 6939(define prim-proc-ref-tag 40960)
 6940(define local-proc-ref-tag 49152)
 6941(define long-index-mask 16383)
 6942(define word-index-mask 2047)
 6943(define (ofile.begin! filename add-obj)
 6944  (set! ofile-add-obj add-obj)
 6945  (set! ofile-syms (queue-empty))
 6946;  (set! *ofile-port1* (open-output-file (string-append filename ".O")))
 6947  (if ofile-asm?
 6948      (begin
 6949        (set! *ofile-port2*
 6950              (asm-open-output-file (string-append filename ".asm")))
 6951        (set! *ofile-pos* 0)))
 6952  (ofile-word ofile-version-major)
 6953  (ofile-word ofile-version-minor)
 6954  '())
 6955(define (ofile.end!)
 6956  (ofile-line "")
 6957;  (close-output-port *ofile-port1*)
 6958  (if ofile-asm? (asm-close-output-port *ofile-port2*))
 6959  '())
 6960(define asm-output '())
 6961(define asm-line '())
 6962(define (asm-open-output-file filename)
 6963  (set! asm-output '())
 6964  (set! asm-line '()))
 6965(define (asm-close-output-port asm-port) #f)
 6966(define (asm-newline asm-port) (asm-display char-newline asm-port))
 6967(define (asm-display obj asm-port)
 6968  (if (eqv? obj char-newline)
 6969      (begin
 6970        (set! asm-output
 6971              (cons (apply string-append (reverse asm-line)) asm-output))
 6972        (set! asm-line '()))
 6973      (set! asm-line
 6974            (cons (cond ((string? obj) obj)
 6975                        ((char? obj) (if (eqv? obj char-tab) " " (string obj)))
 6976                        ((number? obj) (number->string obj))
 6977                        (else (compiler-internal-error "asm-display" obj)))
 6978                  asm-line))))
 6979(define (asm-output-get) (reverse asm-output))
 6980(define *ofile-port1* '())
 6981(define *ofile-port2* '())
 6982(define *ofile-pos* '())
 6983(define ofile-nl char-newline)
 6984(define ofile-tab char-tab)
 6985(define ofile-asm? '())
 6986(set! ofile-asm? '())
 6987(define ofile-asm-bits? '())
 6988(set! ofile-asm-bits? #f)
 6989(define ofile-asm-gvm? '())
 6990(set! ofile-asm-gvm? #f)
 6991(define ofile-stats? '())
 6992(set! ofile-stats? '())
 6993(define ofile-add-obj '())
 6994(set! ofile-add-obj '())
 6995(define ofile-syms '())
 6996(set! ofile-syms '())
 6997(define (ofile-word n)
 6998  (let ((n (modulo n 65536)))
 6999    (if (and ofile-asm? ofile-asm-bits?)
 7000        (let ()
 7001          (define (ofile-display x)
 7002            (asm-display x *ofile-port2*)
 7003            (cond ((eq? x ofile-nl) (set! *ofile-pos* 0))
 7004                  ((eq? x ofile-tab)
 7005                   (set! *ofile-pos* (* (quotient (+ *ofile-pos* 8) 8) 8)))
 7006                  (else (set! *ofile-pos* (+ *ofile-pos* (string-length x))))))
 7007          (if (> *ofile-pos* 64) (ofile-display ofile-nl))
 7008          (if (= *ofile-pos* 0) (ofile-display " .word") (ofile-display ","))
 7009          (ofile-display ofile-tab)
 7010          (let ((s (make-string 6 #\0)))
 7011            (string-set! s 1 #\x)
 7012            (let loop ((i 5) (n n))
 7013              (if (> n 0)
 7014                  (begin
 7015                    (string-set!
 7016                     s
 7017                     i
 7018                     (string-ref "0123456789ABCDEF" (remainder n 16)))
 7019                    (loop (- i 1) (quotient n 16)))))
 7020            (ofile-display s))))
 7021'    (write-word n *ofile-port1*)))
 7022(define (ofile-long x) (ofile-word (upper-16bits x)) (ofile-word x))
 7023(define (ofile-string s)
 7024  (let ((len (string-length s)))
 7025    (define (ref i) (if (>= i len) 0 (character-encoding (string-ref s i))))
 7026    (let loop ((i 0))
 7027      (if (< i len)
 7028          (begin
 7029            (ofile-word (+ (* (ref i) 256) (ref (+ i 1))))
 7030            (loop (+ i 2)))))
 7031    (if (= (remainder len 2) 0) (ofile-word 0))))
 7032(define (ofile-wsym tag name)
 7033  (let ((n (string-pos-in-list name (queue->list ofile-syms))))
 7034    (if n
 7035        (ofile-word (+ tag n))
 7036        (let ((m (length (queue->list ofile-syms))))
 7037          (queue-put! ofile-syms name)
 7038          (ofile-word (+ tag word-index-mask))
 7039          (ofile-string name)))))
 7040(define (ofile-lsym tag name)
 7041  (let ((n (string-pos-in-list name (queue->list ofile-syms))))
 7042    (if n
 7043        (ofile-long (+ tag (* n 8)))
 7044        (let ((m (length (queue->list ofile-syms))))
 7045          (queue-put! ofile-syms name)
 7046          (ofile-long (+ tag (* long-index-mask 8)))
 7047          (ofile-string name)))))
 7048(define (ofile-ref obj)
 7049  (let ((n (obj-encoding obj)))
 7050    (if n
 7051        (ofile-long n)
 7052        (if (symbol-object? obj)
 7053            (begin (ofile-lsym symbol-object-bits (symbol->string obj)))
 7054            (let ((m (ofile-add-obj obj)))
 7055              (if m
 7056                  (ofile-long (+ local-object-bits (* m 8)))
 7057                  (begin
 7058                    (ofile-lsym
 7059                     prim-proc-object-bits
 7060                     (proc-obj-name obj)))))))))
 7061(define (ofile-prim-proc s)
 7062  (ofile-long prim-proc-prefix)
 7063  (ofile-wsym 0 s)
 7064  (ofile-comment (list "| #[primitive " s "] =")))
 7065(define (ofile-user-proc) (ofile-long user-proc-prefix))
 7066(define (ofile-line s)
 7067  (if ofile-asm?
 7068      (begin
 7069        (if (> *ofile-pos* 0) (asm-newline *ofile-port2*))
 7070        (asm-display s *ofile-port2*)
 7071        (asm-newline *ofile-port2*)
 7072        (set! *ofile-pos* 0))))
 7073(define (ofile-tabs-to n)
 7074  (let loop ()
 7075    (if (< *ofile-pos* n)
 7076        (begin
 7077          (asm-display ofile-tab *ofile-port2*)
 7078          (set! *ofile-pos* (* (quotient (+ *ofile-pos* 8) 8) 8))
 7079          (loop)))))
 7080(define (ofile-comment l)
 7081  (if ofile-asm?
 7082      (let ()
 7083        (if ofile-asm-bits?
 7084            (begin (ofile-tabs-to 32) (asm-display "|" *ofile-port2*)))
 7085        (for-each (lambda (x) (asm-display x *ofile-port2*)) l)
 7086        (asm-newline *ofile-port2*)
 7087        (set! *ofile-pos* 0))))
 7088(define (ofile-gvm-instr code)
 7089  (if (and ofile-asm? ofile-asm-gvm?)
 7090      (let ((gvm-instr (code-gvm-instr code)) (sn (code-slots-needed code)))
 7091        (if (> *ofile-pos* 0)
 7092            (begin (asm-newline *ofile-port2*) (set! *ofile-pos* 0)))
 7093        (if ofile-asm-bits? (ofile-tabs-to 32))
 7094        (asm-display "| GVM: [" *ofile-port2*)
 7095        (asm-display sn *ofile-port2*)
 7096        (asm-display "] " *ofile-port2*)
 7097        (asm-newline *ofile-port2*)
 7098        (set! *ofile-pos* 0))))
 7099(define (ofile-stat stat)
 7100  (define (obj->string x)
 7101    (cond ((string? x) x)
 7102          ((symbol-object? x) (symbol->string x))
 7103          ((number? x) (number->string x))
 7104          ((false-object? x) "#f")
 7105          ((eq? x #t) "#t")
 7106          ((null? x) "()")
 7107          ((pair? x)
 7108           (let loop ((l1 (cdr x)) (l2 (list (obj->string (car x)) "(")))
 7109             (cond ((pair? l1)
 7110                    (loop (cdr l1)
 7111                          (cons (obj->string (car l1)) (cons " " l2))))
 7112                   ((null? l1) (apply string-append (reverse (cons ")" l2))))
 7113                   (else
 7114                    (apply string-append
 7115                           (reverse (cons ")"
 7116                                          (cons (obj->string l1)
 7117                                                (cons " . " l2)))))))))
 7118          (else
 7119           (compiler-internal-error
 7120            "ofile-stat, can't convert to string 'x'"
 7121            x))))
 7122  (ofile-string (obj->string stat)))
 7123(define (upper-16bits x)
 7124  (cond ((>= x 0) (quotient x 65536))
 7125        ((>= x (- 65536)) -1)
 7126        (else (- (quotient (+ x 65537) 65536) 2))))
 7127(define type-fixnum 0)
 7128(define type-flonum 1)
 7129(define type-special 7)
 7130(define type-pair 4)
 7131(define type-placeholder 5)
 7132(define type-subtyped 3)
 7133(define type-procedure 2)
 7134(define subtype-vector 0)
 7135(define subtype-symbol 1)
 7136(define subtype-port 2)
 7137(define subtype-ratnum 3)
 7138(define subtype-cpxnum 4)
 7139(define subtype-string 16)
 7140(define subtype-bignum 17)
 7141(define data-false (- 33686019))
 7142(define data-null (- 67372037))
 7143(define data-true -2)
 7144(define data-undef -3)
 7145(define data-unass -4)
 7146(define data-unbound -5)
 7147(define data-eof -6)
 7148(define data-max-fixnum 268435455)
 7149(define data-min-fixnum (- 268435456))
 7150(define (make-encoding data type) (+ (* data 8) type))
 7151(define (obj-type obj)
 7152  (cond ((false-object? obj) 'special)
 7153        ((undef-object? obj) 'special)
 7154        ((symbol-object? obj) 'subtyped)
 7155        ((proc-obj? obj) 'procedure)
 7156        ((eq? obj #t) 'special)
 7157        ((null? obj) 'special)
 7158        ((pair? obj) 'pair)
 7159        ((number? obj)
 7160         (cond ((and (integer? obj)
 7161                     (exact? obj)
 7162                     (>= obj data-min-fixnum)
 7163                     (<= obj data-max-fixnum))
 7164                'fixnum)
 7165               (
 7166#t
 7167;;                (and (inexact? (real-part obj))
 7168;;                     (zero? (imag-part obj))
 7169;;                     (exact? (imag-part obj)))
 7170                'flonum)
 7171               (else 'subtyped)))
 7172        ((char? obj) 'special)
 7173        (else 'subtyped)))
 7174(define (obj-subtype obj)
 7175  (cond ((symbol-object? obj) 'symbol)
 7176        ((number? obj)
 7177         (cond ((and (integer? obj) (exact? obj)) 'bignum)
 7178               ((and (rational? obj) (exact? obj)) 'ratnum)
 7179               (else 'cpxnum)))
 7180        ((vector? obj) 'vector)
 7181        ((string? obj) 'string)
 7182        (else
 7183         (compiler-internal-error "obj-subtype, unknown object 'obj'" obj))))
 7184(define (obj-type-tag obj)
 7185  (case (obj-type obj)
 7186    ((fixnum) type-fixnum)
 7187    ((flonum) type-flonum)
 7188    ((special) type-special)
 7189    ((pair) type-pair)
 7190    ((subtyped) type-subtyped)
 7191    ((procedure) type-procedure)
 7192    (else (compiler-internal-error "obj-type-tag, unknown object 'obj'" obj))))
 7193(define (obj-encoding obj)
 7194  (case (obj-type obj)
 7195    ((fixnum) (make-encoding obj type-fixnum))
 7196    ((special)
 7197     (make-encoding
 7198      (cond ((false-object? obj) data-false)
 7199            ((undef-object? obj) data-undef)
 7200            ((eq? obj #t) data-true)
 7201            ((null? obj) data-null)
 7202            ((char? obj) (character-encoding obj))
 7203            (else
 7204             (compiler-internal-error
 7205              "obj-encoding, unknown SPECIAL object 'obj'"
 7206              obj)))
 7207      type-special))
 7208    (else #f)))
 7209(define bits-false (make-encoding data-false type-special))
 7210(define bits-null (make-encoding data-null type-special))
 7211(define bits-true (make-encoding data-true type-special))
 7212(define bits-unass (make-encoding data-unass type-special))
 7213(define bits-unbound (make-encoding data-unbound type-special))
 7214(define (asm.begin!)
 7215  (set! asm-code-queue (queue-empty))
 7216  (set! asm-const-queue (queue-empty))
 7217  '())
 7218(define (asm.end! debug-info)
 7219  (asm-assemble! debug-info)
 7220  (set! asm-code-queue '())
 7221  (set! asm-const-queue '())
 7222  '())
 7223(define asm-code-queue '())
 7224(define asm-const-queue '())
 7225(define (asm-word x) (queue-put! asm-code-queue (modulo x 65536)))
 7226(define (asm-long x) (asm-word (upper-16bits x)) (asm-word x))
 7227(define (asm-label lbl label-descr)
 7228  (queue-put! asm-code-queue (cons 'label (cons lbl label-descr))))
 7229(define (asm-comment x) (queue-put! asm-code-queue (cons 'comment x)))
 7230(define (asm-align n offset)
 7231  (queue-put! asm-code-queue (cons 'align (cons n offset))))
 7232(define (asm-ref-glob glob)
 7233  (queue-put!
 7234   asm-code-queue
 7235   (cons 'ref-glob (symbol->string (glob-name glob)))))
 7236(define (asm-set-glob glob)
 7237  (queue-put!
 7238   asm-code-queue
 7239   (cons 'set-glob (symbol->string (glob-name glob)))))
 7240(define (asm-ref-glob-jump glob)
 7241  (queue-put!
 7242   asm-code-queue
 7243   (cons 'ref-glob-jump (symbol->string (glob-name glob)))))
 7244(define (asm-proc-ref num offset)
 7245  (queue-put! asm-code-queue (cons 'proc-ref (cons num offset))))
 7246(define (asm-prim-ref proc offset)
 7247  (queue-put!
 7248   asm-code-queue
 7249   (cons 'prim-ref (cons (proc-obj-name proc) offset))))
 7250(define (asm-m68020-proc) (queue-put! asm-code-queue '(m68020-proc)))
 7251(define (asm-m68881-proc) (queue-put! asm-code-queue '(m68881-proc)))
 7252(define (asm-stat x) (queue-put! asm-code-queue (cons 'stat x)))
 7253(define (asm-brel type lbl)
 7254  (queue-put! asm-code-queue (cons 'brab (cons type lbl))))
 7255(define (asm-wrel lbl offs)
 7256  (queue-put! asm-code-queue (cons 'wrel (cons lbl offs))))
 7257(define (asm-lrel lbl offs n)
 7258  (queue-put! asm-code-queue (cons 'lrel (cons lbl (cons offs n)))))
 7259(define (asm-assemble! debug-info)
 7260  (define header-offset 2)
 7261  (define ref-glob-len 2)
 7262  (define set-glob-len 10)
 7263  (define ref-glob-jump-len 2)
 7264  (define proc-ref-len 4)
 7265  (define prim-ref-len 4)
 7266  (define stat-len 4)
 7267  (define (padding loc n offset) (modulo (- offset loc) n))
 7268  (queue-put! asm-const-queue debug-info)
 7269  (asm-align 4 0)
 7270  (emit-label const-lbl)
 7271  (let ((code-list (queue->list asm-code-queue))
 7272        (const-list (queue->list asm-const-queue)))
 7273    (let* ((fix-list
 7274            (let loop ((l code-list) (len header-offset) (x '()))
 7275              (if (null? l)
 7276                  (reverse x)
 7277                  (let ((part (car l)) (rest (cdr l)))
 7278                    (if (pair? part)
 7279                        (case (car part)
 7280                          ((label align brab)
 7281                           (loop rest 0 (cons (cons len part) x)))
 7282                          ((wrel) (loop rest (+ len 2) x))
 7283                          ((lrel) (loop rest (+ len 4) x))
 7284                          ((ref-glob) (loop rest (+ len ref-glob-len) x))
 7285                          ((set-glob) (loop rest (+ len set-glob-len) x))
 7286                          ((ref-glob-jump)
 7287                           (loop rest (+ len ref-glob-jump-len) x))
 7288                          ((proc-ref) (loop rest (+ len proc-ref-len) x))
 7289                          ((prim-ref) (loop rest (+ len prim-ref-len) x))
 7290                          ((stat) (loop rest (+ len stat-len) x))
 7291                          ((comment m68020-proc m68881-proc) (loop rest len x))
 7292                          (else
 7293                           (compiler-internal-error
 7294                            "asm-assemble!, unknown code list element"
 7295                            part)))
 7296                        (loop rest (+ len 2) x))))))
 7297           (lbl-list
 7298            (let loop ((l fix-list) (x '()))
 7299              (if (null? l)
 7300                  x
 7301                  (let ((part (cdar l)) (rest (cdr l)))
 7302                    (if (eq? (car part) 'label)
 7303                        (loop rest (cons (cons (cadr part) part) x))
 7304                        (loop rest x)))))))
 7305      (define (replace-lbl-refs-by-pointer-to-label)
 7306        (let loop ((l code-list))
 7307          (if (not (null? l))
 7308              (let ((part (car l)) (rest (cdr l)))
 7309                (if (pair? part)
 7310                    (case (car part)
 7311                      ((brab)
 7312                       (set-cdr! (cdr part) (cdr (assq (cddr part) lbl-list))))
 7313                      ((wrel)
 7314                       (set-car! (cdr part) (cdr (assq (cadr part) lbl-list))))
 7315                      ((lrel)
 7316                       (set-car!
 7317                        (cdr part)
 7318                        (cdr (assq (cadr part) lbl-list))))))
 7319                (loop rest)))))
 7320      (define (assign-loc-to-labels)
 7321        (let loop ((l fix-list) (loc 0))
 7322          (if (not (null? l))
 7323              (let* ((first (car l))
 7324                     (rest (cdr l))
 7325                     (len (car first))
 7326                     (cur-loc (+ loc len))
 7327                     (part (cdr first)))
 7328                (case (car part)
 7329                  ((label)
 7330                   (if (cddr part)
 7331                       (vector-set!
 7332                        (cddr part)
 7333                        0
 7334                        (quotient (- cur-loc header-offset) 8)))
 7335                   (set-car! (cdr part) cur-loc)
 7336                   (loop rest cur-loc))
 7337                  ((align)
 7338                   (loop rest
 7339                         (+ cur-loc
 7340                            (padding cur-loc (cadr part) (cddr part)))))
 7341                  ((brab) (loop rest (+ cur-loc 2)))
 7342                  ((braw) (loop rest (+ cur-loc 4)))
 7343                  (else
 7344                   (compiler-internal-error
 7345                    "assign-loc-to-labels, unknown code list element"
 7346                    part)))))))
 7347      (define (branch-tensioning-pass)
 7348        (assign-loc-to-labels)
 7349        (let loop ((changed? #f) (l fix-list) (loc 0))
 7350          (if (null? l)
 7351              (if changed? (branch-tensioning-pass))
 7352              (let* ((first (car l))
 7353                     (rest (cdr l))
 7354                     (len (car first))
 7355                     (cur-loc (+ loc len))
 7356                     (part (cdr first)))
 7357                (case (car part)
 7358                  ((label) (loop changed? rest cur-loc))
 7359                  ((align)
 7360                   (loop changed?
 7361                         rest
 7362                         (+ cur-loc
 7363                            (padding cur-loc (cadr part) (cddr part)))))
 7364                  ((brab)
 7365                   (let ((dist (- (cadr (cddr part)) (+ cur-loc 2))))
 7366                     (if (or (< dist -128) (> dist 127) (= dist 0))
 7367                         (begin
 7368                           (set-car! part 'braw)
 7369                           (loop #t rest (+ cur-loc 2)))
 7370                         (loop changed? rest (+ cur-loc 2)))))
 7371                  ((braw) (loop changed? rest (+ cur-loc 4)))
 7372                  (else
 7373                   (compiler-internal-error
 7374                    "branch-tensioning-pass, unknown code list element"
 7375                    part)))))))
 7376      (define (write-block start-loc end-loc start end)
 7377        (if (> end-loc start-loc)
 7378            (ofile-word (quotient (- end-loc start-loc) 2)))
 7379        (let loop ((loc start-loc) (l start))
 7380          (if (not (eq? l end))
 7381              (let ((part (car l)) (rest (cdr l)))
 7382                (if (pair? part)
 7383                    (case (car part)
 7384                      ((label) (loop loc rest))
 7385                      ((align)
 7386                       (let ((n (padding loc (cadr part) (cddr part))))
 7387                         (let pad ((i 0))
 7388                           (if (< i n)
 7389                               (begin (ofile-word 0) (pad (+ i 2)))
 7390                               (loop (+ loc n) rest)))))
 7391                      ((brab)
 7392                       (let ((dist (- (cadr (cddr part)) (+ loc 2))))
 7393                         (ofile-word (+ (cadr part) (modulo dist 256)))
 7394                         (loop (+ loc 2) rest)))
 7395                      ((braw)
 7396                       (let ((dist (- (cadr (cddr part)) (+ loc 2))))
 7397                         (ofile-word (cadr part))
 7398                         (ofile-word (modulo dist 65536))
 7399                         (loop (+ loc 4) rest)))
 7400                      ((wrel)
 7401                       (let ((dist (+ (- (cadr (cadr part)) loc) (cddr part))))
 7402                         (ofile-word (modulo dist 65536))
 7403                         (loop (+ loc 2) rest)))
 7404                      ((lrel)
 7405                       (let ((dist (+ (- (cadr (cadr part)) loc)
 7406                                      (caddr part))))
 7407                         (ofile-long (+ (* dist 65536) (cdddr part)))
 7408                         (loop (+ loc 4) rest)))
 7409                      ((comment)
 7410                       (let ((x (cdr part)))
 7411                         (if (pair? x) (ofile-comment x) (ofile-gvm-instr x))
 7412                         (loop loc rest))))
 7413                    (begin (ofile-word part) (loop (+ loc 2) rest)))))))
 7414      (define (write-code)
 7415        (let ((proc-len
 7416               (+ (cadr (cdr (assq const-lbl lbl-list)))
 7417                  (* (length const-list) 4))))
 7418          (if (>= proc-len 32768)
 7419              (compiler-limitation-error
 7420               "procedure is too big (32K bytes limit per procedure)"))
 7421          (ofile-word (+ 32768 proc-len)))
 7422        (let loop1 ((start code-list) (start-loc header-offset))
 7423          (let loop2 ((end start) (loc start-loc))
 7424            (if (null? end)
 7425                (write-block start-loc loc start end)
 7426                (let ((part (car end)) (rest (cdr end)))
 7427                  (if (pair? part)
 7428                      (case (car part)
 7429                        ((label comment) (loop2 rest loc))
 7430                        ((align)
 7431                         (loop2 rest
 7432                                (+ loc (padding loc (cadr part) (cddr part)))))
 7433                        ((brab wrel) (loop2 rest (+ loc 2)))
 7434                        ((braw) (loop2 rest (+ loc 4)))
 7435                        ((lrel) (loop2 rest (+ loc 4)))
 7436                        (else
 7437                         (write-block start-loc loc start end)
 7438                         (case (car part)
 7439                           ((ref-glob)
 7440                            (ofile-wsym global-var-ref-tag (cdr part))
 7441                            (loop1 rest (+ loc ref-glob-len)))
 7442                           ((set-glob)
 7443                            (ofile-wsym global-var-set-tag (cdr part))
 7444                            (loop1 rest (+ loc set-glob-len)))
 7445                           ((ref-glob-jump)
 7446                            (ofile-wsym global-var-ref-jump-tag (cdr part))
 7447                            (loop1 rest (+ loc ref-glob-jump-len)))
 7448                           ((proc-ref)
 7449                            (ofile-word (+ local-proc-ref-tag (cadr part)))
 7450                            (ofile-word (cddr part))
 7451                            (loop1 rest (+ loc proc-ref-len)))
 7452                           ((prim-ref)
 7453                            (ofile-wsym prim-proc-ref-tag (cadr part))
 7454                            (ofile-word (cddr part))
 7455                            (loop1 rest (+ loc prim-ref-len)))
 7456                           ((m68020-proc)
 7457                            (ofile-word m68020-proc-code-tag)
 7458                            (loop1 rest loc))
 7459                           ((m68881-proc)
 7460                            (ofile-word m68881-proc-code-tag)
 7461                            (loop1 rest loc))
 7462                           ((stat)
 7463                            (ofile-word stat-tag)
 7464                            (ofile-stat (cdr part))
 7465                            (loop1 rest (+ loc stat-len))))))
 7466                      (loop2 rest (+ loc 2)))))))
 7467        (ofile-word end-of-code-tag)
 7468        (for-each ofile-ref const-list)
 7469        (ofile-long (obj-encoding (+ (length const-list) 1))))
 7470      (replace-lbl-refs-by-pointer-to-label)
 7471      (branch-tensioning-pass)
 7472      (write-code))))
 7473(define const-lbl 0)
 7474(define (identical-opnd68? opnd1 opnd2) (eqv? opnd1 opnd2))
 7475(define (reg68? x) (or (dreg? x) (areg? x)))
 7476(define (make-dreg num) num)
 7477(define (dreg? x) (and (integer? x) (>= x 0) (< x 8)))
 7478(define (dreg-num x) x)
 7479(define (make-areg num) (+ num 8))
 7480(define (areg? x) (and (integer? x) (>= x 8) (< x 16)))
 7481(define (areg-num x) (- x 8))
 7482(define (make-ind areg) (+ areg 8))
 7483(define (ind? x) (and (integer? x) (>= x 16) (< x 24)))
 7484(define (ind-areg x) (- x 8))
 7485(define (make-pinc areg) (+ areg 16))
 7486(define (pinc? x) (and (integer? x) (>= x 24) (< x 32)))
 7487(define (pinc-areg x) (- x 16))
 7488(define (make-pdec areg) (+ areg 24))
 7489(define (pdec? x) (and (integer? x) (>= x 32) (< x 40)))
 7490(define (pdec-areg x) (- x 24))
 7491(define (make-disp areg offset) (+ (+ areg 32) (* (modulo offset 65536) 8)))
 7492(define (disp? x) (and (integer? x) (>= x 40) (< x 524328)))
 7493(define (disp-areg x) (+ (remainder x 8) 8))
 7494(define (disp-offset x)
 7495  (- (modulo (+ (quotient (- x 40) 8) 32768) 65536) 32768))
 7496(define (make-disp* areg offset)
 7497  (if (= offset 0) (make-ind areg) (make-disp areg offset)))
 7498(define (disp*? x) (or (ind? x) (disp? x)))
 7499(define (disp*-areg x) (if (ind? x) (ind-areg x) (disp-areg x)))
 7500(define (disp*-offset x) (if (ind? x) 0 (disp-offset x)))
 7501(define (make-inx areg ireg offset)
 7502  (+ (+ areg 524320) (* ireg 8) (* (modulo offset 256) 128)))
 7503(define (inx? x) (and (integer? x) (>= x 524328) (< x 557096)))
 7504(define (inx-areg x) (+ (remainder (- x 524328) 8) 8))
 7505(define (inx-ireg x) (quotient (remainder (- x 524328) 128) 8))
 7506(define (inx-offset x)
 7507  (- (modulo (+ (quotient (- x 524328) 128) 128) 256) 128))
 7508(define (make-freg num) (+ 557096 num))
 7509(define (freg? x) (and (integer? x) (>= x 557096) (< x 557104)))
 7510(define (freg-num x) (- x 557096))
 7511(define (make-pcr lbl offset)
 7512  (+ 557104 (+ (modulo offset 65536) (* lbl 65536))))
 7513(define (pcr? x) (and (integer? x) (>= x 557104)))
 7514(define (pcr-lbl x) (quotient (- x 557104) 65536))
 7515(define (pcr-offset x) (- (modulo (- x 524336) 65536) 32768))
 7516(define (make-imm val) (if (< val 0) (* val 2) (- -1 (* val 2))))
 7517(define (imm? x) (and (integer? x) (< x 0)))
 7518(define (imm-val x) (if (even? x) (quotient x 2) (- (quotient x 2))))
 7519(define (make-glob name) name)
 7520(define (glob? x) (symbol? x))
 7521(define (glob-name x) x)
 7522(define (make-frame-base-rel slot) (make-disp sp-reg slot))
 7523(define (frame-base-rel? x)
 7524  (and (disp? x) (identical-opnd68? sp-reg (disp-areg x))))
 7525(define (frame-base-rel-slot x) (disp-offset x))
 7526(define (make-reg-list regs) regs)
 7527(define (reg-list? x) (or (pair? x) (null? x)))
 7528(define (reg-list-regs x) x)
 7529(define first-dtemp 0)
 7530(define gvm-reg1 1)
 7531(define poll-timer-reg (make-dreg 5))
 7532(define null-reg (make-dreg 6))
 7533(define placeholder-reg (make-dreg 6))
 7534(define false-reg (make-dreg 7))
 7535(define pair-reg (make-dreg 7))
 7536(define gvm-reg0 0)
 7537(define first-atemp 1)
 7538(define heap-reg (make-areg 3))
 7539(define ltq-tail-reg (make-areg 4))
 7540(define pstate-reg (make-areg 5))
 7541(define table-reg (make-areg 6))
 7542(define sp-reg (make-areg 7))
 7543(define pdec-sp (make-pdec sp-reg))
 7544(define pinc-sp (make-pinc sp-reg))
 7545(define dtemp1 (make-dreg first-dtemp))
 7546(define atemp1 (make-areg first-atemp))
 7547(define atemp2 (make-areg (+ first-atemp 1)))
 7548(define ftemp1 (make-freg 0))
 7549(define arg-count-reg dtemp1)
 7550(define (trap-offset n) (+ 32768 (* (- n 32) 8)))
 7551(define (emit-move.l opnd1 opnd2)
 7552  (let ((src (opnd->mode/reg opnd1)) (dst (opnd->reg/mode opnd2)))
 7553    (asm-word (+ 8192 (+ dst src)))
 7554    (opnd-ext-rd-long opnd1)
 7555    (opnd-ext-wr-long opnd2)
 7556    (if ofile-asm?
 7557        (emit-asm "movl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2)))))
 7558(define (emit-move.w opnd1 opnd2)
 7559  (let ((src (opnd->mode/reg opnd1)) (dst (opnd->reg/mode opnd2)))
 7560    (asm-word (+ 12288 (+ dst src)))
 7561    (opnd-ext-rd-word opnd1)
 7562    (opnd-ext-wr-word opnd2)
 7563    (if ofile-asm?
 7564        (emit-asm "movw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2)))))
 7565(define (emit-move.b opnd1 opnd2)
 7566  (let ((src (opnd->mode/reg opnd1)) (dst (opnd->reg/mode opnd2)))
 7567    (asm-word (+ 4096 (+ dst src)))
 7568    (opnd-ext-rd-word opnd1)
 7569    (opnd-ext-wr-word opnd2)
 7570    (if ofile-asm?
 7571        (emit-asm "movb" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2)))))
 7572(define (emit-moveq n opnd)
 7573  (asm-word (+ 28672 (+ (* (dreg-num opnd) 512) (modulo n 256))))
 7574  (if ofile-asm? (emit-asm "moveq" ofile-tab "#" n "," (opnd-str opnd))))
 7575(define (emit-movem.l opnd1 opnd2)
 7576  (define (reg-mask reg-list flip-bits?)
 7577    (let loop ((i 15) (bit 32768) (mask 0))
 7578      (if (>= i 0)
 7579          (loop (- i 1)
 7580                (quotient bit 2)
 7581                (if (memq i reg-list)
 7582                    (+ mask (if flip-bits? (quotient 32768 bit) bit))
 7583                    mask))
 7584          mask)))
 7585  (define (movem op reg-list opnd)
 7586    (asm-word (+ op (opnd->mode/reg opnd)))
 7587    (asm-word (reg-mask reg-list (pdec? opnd))))
 7588  (if (reg-list? opnd1)
 7589      (begin (movem 18624 opnd1 opnd2) (opnd-ext-wr-long opnd2))
 7590      (begin (movem 19648 opnd2 opnd1) (opnd-ext-rd-long opnd1)))
 7591  (if ofile-asm?
 7592      (emit-asm "moveml" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7593(define (emit-exg opnd1 opnd2)
 7594  (define (exg r1 r2)
 7595    (let ((mode (if (dreg? r2) 49472 (if (dreg? r1) 49544 49480)))
 7596          (num1 (if (dreg? r1) (dreg-num r1) (areg-num r1)))
 7597          (num2 (if (dreg? r2) (dreg-num r2) (areg-num r2))))
 7598      (asm-word (+ mode (+ (* num1 512) num2)))))
 7599  (if (dreg? opnd2) (exg opnd2 opnd1) (exg opnd1 opnd2))
 7600  (if ofile-asm?
 7601      (emit-asm "exg" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7602(define (emit-eor.l opnd1 opnd2)
 7603  (cond ((imm? opnd1)
 7604         (asm-word (+ 2688 (opnd->mode/reg opnd2)))
 7605         (opnd-ext-rd-long opnd1)
 7606         (opnd-ext-wr-long opnd2))
 7607        (else
 7608         (asm-word
 7609          (+ 45440 (+ (* (dreg-num opnd1) 512) (opnd->mode/reg opnd2))))
 7610         (opnd-ext-wr-long opnd2)))
 7611  (if ofile-asm?
 7612      (emit-asm "eorl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7613(define (emit-and.l opnd1 opnd2)
 7614  (cond ((imm? opnd1)
 7615         (asm-word (+ 640 (opnd->mode/reg opnd2)))
 7616         (opnd-ext-rd-long opnd1)
 7617         (opnd-ext-wr-long opnd2))
 7618        (else
 7619         (let ((mode (if (dreg? opnd2) 49280 49536))
 7620               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7621               (other (if (dreg? opnd2) opnd1 opnd2)))
 7622           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7623           (if (dreg? opnd2)
 7624               (opnd-ext-rd-long other)
 7625               (opnd-ext-wr-long other)))))
 7626  (if ofile-asm?
 7627      (emit-asm "andl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7628(define (emit-and.w opnd1 opnd2)
 7629  (cond ((imm? opnd1)
 7630         (asm-word (+ 576 (opnd->mode/reg opnd2)))
 7631         (opnd-ext-rd-word opnd1)
 7632         (opnd-ext-wr-word opnd2))
 7633        (else
 7634         (let ((mode (if (dreg? opnd2) 49216 49472))
 7635               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7636               (other (if (dreg? opnd2) opnd1 opnd2)))
 7637           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7638           (if (dreg? opnd2)
 7639               (opnd-ext-rd-word other)
 7640               (opnd-ext-wr-word other)))))
 7641  (if ofile-asm?
 7642      (emit-asm "andw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7643(define (emit-or.l opnd1 opnd2)
 7644  (cond ((imm? opnd1)
 7645         (asm-word (+ 128 (opnd->mode/reg opnd2)))
 7646         (opnd-ext-rd-long opnd1)
 7647         (opnd-ext-wr-long opnd2))
 7648        (else
 7649         (let ((mode (if (dreg? opnd2) 32896 33152))
 7650               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7651               (other (if (dreg? opnd2) opnd1 opnd2)))
 7652           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7653           (if (dreg? opnd2)
 7654               (opnd-ext-rd-long other)
 7655               (opnd-ext-wr-long other)))))
 7656  (if ofile-asm?
 7657      (emit-asm "orl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7658(define (emit-addq.l n opnd)
 7659  (let ((m (if (= n 8) 0 n)))
 7660    (asm-word (+ 20608 (* m 512) (opnd->mode/reg opnd)))
 7661    (opnd-ext-wr-long opnd)
 7662    (if ofile-asm? (emit-asm "addql" ofile-tab "#" n "," (opnd-str opnd)))))
 7663(define (emit-addq.w n opnd)
 7664  (let ((m (if (= n 8) 0 n)))
 7665    (asm-word (+ 20544 (* m 512) (opnd->mode/reg opnd)))
 7666    (opnd-ext-wr-word opnd)
 7667    (if ofile-asm? (emit-asm "addqw" ofile-tab "#" n "," (opnd-str opnd)))))
 7668(define (emit-add.l opnd1 opnd2)
 7669  (cond ((areg? opnd2)
 7670         (asm-word
 7671          (+ 53696 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7672         (opnd-ext-rd-long opnd1))
 7673        ((imm? opnd1)
 7674         (asm-word (+ 1664 (opnd->mode/reg opnd2)))
 7675         (opnd-ext-rd-long opnd1)
 7676         (opnd-ext-wr-long opnd2))
 7677        (else
 7678         (let ((mode (if (dreg? opnd2) 53376 53632))
 7679               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7680               (other (if (dreg? opnd2) opnd1 opnd2)))
 7681           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7682           (if (dreg? opnd2)
 7683               (opnd-ext-rd-long other)
 7684               (opnd-ext-wr-long other)))))
 7685  (if ofile-asm?
 7686      (emit-asm "addl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7687(define (emit-add.w opnd1 opnd2)
 7688  (cond ((areg? opnd2)
 7689         (asm-word
 7690          (+ 53440 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7691         (opnd-ext-rd-word opnd1))
 7692        ((imm? opnd1)
 7693         (asm-word (+ 1600 (opnd->mode/reg opnd2)))
 7694         (opnd-ext-rd-word opnd1)
 7695         (opnd-ext-wr-word opnd2))
 7696        (else
 7697         (let ((mode (if (dreg? opnd2) 53312 53568))
 7698               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7699               (other (if (dreg? opnd2) opnd1 opnd2)))
 7700           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7701           (if (dreg? opnd2)
 7702               (opnd-ext-rd-word other)
 7703               (opnd-ext-wr-word other)))))
 7704  (if ofile-asm?
 7705      (emit-asm "addw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7706(define (emit-addx.w opnd1 opnd2)
 7707  (if (dreg? opnd1)
 7708      (asm-word (+ 53568 (+ (* (dreg-num opnd2) 512) (dreg-num opnd1))))
 7709      (asm-word
 7710       (+ 53576
 7711          (+ (* (areg-num (pdec-areg opnd2)) 512)
 7712             (areg-num (pdec-areg opnd1))))))
 7713  (if ofile-asm?
 7714      (emit-asm "addxw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7715(define (emit-subq.l n opnd)
 7716  (let ((m (if (= n 8) 0 n)))
 7717    (asm-word (+ 20864 (* m 512) (opnd->mode/reg opnd)))
 7718    (opnd-ext-wr-long opnd)
 7719    (if ofile-asm? (emit-asm "subql" ofile-tab "#" n "," (opnd-str opnd)))))
 7720(define (emit-subq.w n opnd)
 7721  (let ((m (if (= n 8) 0 n)))
 7722    (asm-word (+ 20800 (* m 512) (opnd->mode/reg opnd)))
 7723    (opnd-ext-wr-word opnd)
 7724    (if ofile-asm? (emit-asm "subqw" ofile-tab "#" n "," (opnd-str opnd)))))
 7725(define (emit-sub.l opnd1 opnd2)
 7726  (cond ((areg? opnd2)
 7727         (asm-word
 7728          (+ 37312 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7729         (opnd-ext-rd-long opnd1))
 7730        ((imm? opnd1)
 7731         (asm-word (+ 1152 (opnd->mode/reg opnd2)))
 7732         (opnd-ext-rd-long opnd1)
 7733         (opnd-ext-wr-long opnd2))
 7734        (else
 7735         (let ((mode (if (dreg? opnd2) 36992 37248))
 7736               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7737               (other (if (dreg? opnd2) opnd1 opnd2)))
 7738           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7739           (if (dreg? opnd2)
 7740               (opnd-ext-rd-long other)
 7741               (opnd-ext-wr-long other)))))
 7742  (if ofile-asm?
 7743      (emit-asm "subl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7744(define (emit-sub.w opnd1 opnd2)
 7745  (cond ((areg? opnd2)
 7746         (asm-word
 7747          (+ 37056 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7748         (opnd-ext-rd-word opnd1))
 7749        ((imm? opnd1)
 7750         (asm-word (+ 1088 (opnd->mode/reg opnd2)))
 7751         (opnd-ext-rd-word opnd1)
 7752         (opnd-ext-wr-word opnd2))
 7753        (else
 7754         (let ((mode (if (dreg? opnd2) 36928 37184))
 7755               (reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
 7756               (other (if (dreg? opnd2) opnd1 opnd2)))
 7757           (asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
 7758           (if (dreg? opnd2)
 7759               (opnd-ext-rd-word other)
 7760               (opnd-ext-wr-word other)))))
 7761  (if ofile-asm?
 7762      (emit-asm "subw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7763(define (emit-asl.l opnd1 opnd2)
 7764  (if (dreg? opnd1)
 7765      (asm-word (+ 57760 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7766      (let ((n (imm-val opnd1)))
 7767        (asm-word (+ 57728 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7768  (if ofile-asm?
 7769      (emit-asm "asll" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7770(define (emit-asl.w opnd1 opnd2)
 7771  (if (dreg? opnd1)
 7772      (asm-word (+ 57696 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7773      (let ((n (imm-val opnd1)))
 7774        (asm-word (+ 57664 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7775  (if ofile-asm?
 7776      (emit-asm "aslw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7777(define (emit-asr.l opnd1 opnd2)
 7778  (if (dreg? opnd1)
 7779      (asm-word (+ 57504 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7780      (let ((n (imm-val opnd1)))
 7781        (asm-word (+ 57472 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7782  (if ofile-asm?
 7783      (emit-asm "asrl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7784(define (emit-asr.w opnd1 opnd2)
 7785  (if (dreg? opnd1)
 7786      (asm-word (+ 57440 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7787      (let ((n (imm-val opnd1)))
 7788        (asm-word (+ 57408 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7789  (if ofile-asm?
 7790      (emit-asm "asrw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7791(define (emit-lsl.l opnd1 opnd2)
 7792  (if (dreg? opnd1)
 7793      (asm-word (+ 57768 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7794      (let ((n (imm-val opnd1)))
 7795        (asm-word (+ 57736 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7796  (if ofile-asm?
 7797      (emit-asm "lsll" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7798(define (emit-lsr.l opnd1 opnd2)
 7799  (if (dreg? opnd1)
 7800      (asm-word (+ 57512 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7801      (let ((n (imm-val opnd1)))
 7802        (asm-word (+ 57480 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7803  (if ofile-asm?
 7804      (emit-asm "lsrl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7805(define (emit-lsr.w opnd1 opnd2)
 7806  (if (dreg? opnd1)
 7807      (asm-word (+ 57448 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
 7808      (let ((n (imm-val opnd1)))
 7809        (asm-word (+ 57416 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
 7810  (if ofile-asm?
 7811      (emit-asm "lsrw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7812(define (emit-clr.l opnd)
 7813  (asm-word (+ 17024 (opnd->mode/reg opnd)))
 7814  (opnd-ext-wr-long opnd)
 7815  (if ofile-asm? (emit-asm "clrl" ofile-tab (opnd-str opnd))))
 7816(define (emit-neg.l opnd)
 7817  (asm-word (+ 17536 (opnd->mode/reg opnd)))
 7818  (opnd-ext-wr-long opnd)
 7819  (if ofile-asm? (emit-asm "negl" ofile-tab (opnd-str opnd))))
 7820(define (emit-not.l opnd)
 7821  (asm-word (+ 18048 (opnd->mode/reg opnd)))
 7822  (opnd-ext-wr-long opnd)
 7823  (if ofile-asm? (emit-asm "notl" ofile-tab (opnd-str opnd))))
 7824(define (emit-ext.l opnd)
 7825  (asm-word (+ 18624 (dreg-num opnd)))
 7826  (if ofile-asm? (emit-asm "extl" ofile-tab (opnd-str opnd))))
 7827(define (emit-ext.w opnd)
 7828  (asm-word (+ 18560 (dreg-num opnd)))
 7829  (if ofile-asm? (emit-asm "extw" ofile-tab (opnd-str opnd))))
 7830(define (emit-swap opnd)
 7831  (asm-word (+ 18496 (dreg-num opnd)))
 7832  (if ofile-asm? (emit-asm "swap" ofile-tab (opnd-str opnd))))
 7833(define (emit-cmp.l opnd1 opnd2)
 7834  (cond ((areg? opnd2)
 7835         (asm-word
 7836          (+ 45504 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7837         (opnd-ext-rd-long opnd1))
 7838        ((imm? opnd1)
 7839         (asm-word (+ 3200 (opnd->mode/reg opnd2)))
 7840         (opnd-ext-rd-long opnd1)
 7841         (opnd-ext-rd-long opnd2))
 7842        (else
 7843         (asm-word
 7844          (+ 45184 (+ (* (dreg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7845         (opnd-ext-rd-long opnd1)))
 7846  (if ofile-asm?
 7847      (emit-asm "cmpl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7848(define (emit-cmp.w opnd1 opnd2)
 7849  (cond ((areg? opnd2)
 7850         (asm-word
 7851          (+ 45248 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7852         (opnd-ext-rd-word opnd1))
 7853        ((imm? opnd1)
 7854         (asm-word (+ 3136 (opnd->mode/reg opnd2)))
 7855         (opnd-ext-rd-word opnd1)
 7856         (opnd-ext-rd-word opnd2))
 7857        (else
 7858         (asm-word
 7859          (+ 45120 (+ (* (dreg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7860         (opnd-ext-rd-word opnd1)))
 7861  (if ofile-asm?
 7862      (emit-asm "cmpw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7863(define (emit-cmp.b opnd1 opnd2)
 7864  (cond ((imm? opnd1)
 7865         (asm-word (+ 3072 (opnd->mode/reg opnd2)))
 7866         (opnd-ext-rd-word opnd1)
 7867         (opnd-ext-rd-word opnd2))
 7868        (else
 7869         (asm-word
 7870          (+ 45056 (+ (* (dreg-num opnd2) 512) (opnd->mode/reg opnd1))))
 7871         (opnd-ext-rd-word opnd1)))
 7872  (if ofile-asm?
 7873      (emit-asm "cmpb" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7874(define (emit-tst.l opnd)
 7875  (asm-word (+ 19072 (opnd->mode/reg opnd)))
 7876  (opnd-ext-rd-long opnd)
 7877  (if ofile-asm? (emit-asm "tstl" ofile-tab (opnd-str opnd))))
 7878(define (emit-tst.w opnd)
 7879  (asm-word (+ 19008 (opnd->mode/reg opnd)))
 7880  (opnd-ext-rd-word opnd)
 7881  (if ofile-asm? (emit-asm "tstw" ofile-tab (opnd-str opnd))))
 7882(define (emit-lea opnd areg)
 7883  (asm-word (+ 16832 (+ (* (areg-num areg) 512) (opnd->mode/reg opnd))))
 7884  (opnd-ext-rd-long opnd)
 7885  (if ofile-asm?
 7886      (emit-asm "lea" ofile-tab (opnd-str opnd) "," (opnd-str areg))))
 7887(define (emit-unlk areg)
 7888  (asm-word (+ 20056 (areg-num areg)))
 7889  (if ofile-asm? (emit-asm "unlk" ofile-tab (opnd-str areg))))
 7890(define (emit-move-proc num opnd)
 7891  (let ((dst (opnd->reg/mode opnd)))
 7892    (asm-word (+ 8192 (+ dst 60)))
 7893    (asm-proc-ref num 0)
 7894    (opnd-ext-wr-long opnd)
 7895    (if ofile-asm? (emit-asm "MOVE_PROC(" num "," (opnd-str opnd) ")"))))
 7896(define (emit-move-prim val opnd)
 7897  (let ((dst (opnd->reg/mode opnd)))
 7898    (asm-word (+ 8192 (+ dst 60)))
 7899    (asm-prim-ref val 0)
 7900    (opnd-ext-wr-long opnd)
 7901    (if ofile-asm?
 7902        (emit-asm "MOVE_PRIM(" (proc-obj-name val) "," (opnd-str opnd) ")"))))
 7903(define (emit-pea opnd)
 7904  (asm-word (+ 18496 (opnd->mode/reg opnd)))
 7905  (opnd-ext-rd-long opnd)
 7906  (if ofile-asm? (emit-asm "pea" ofile-tab (opnd-str opnd))))
 7907(define (emit-pea* n)
 7908  (asm-word 18552)
 7909  (asm-word n)
 7910  (if ofile-asm? (emit-asm "pea" ofile-tab n)))
 7911(define (emit-btst opnd1 opnd2)
 7912  (asm-word (+ 256 (+ (* (dreg-num opnd1) 512) (opnd->mode/reg opnd2))))
 7913  (opnd-ext-rd-word opnd2)
 7914  (if ofile-asm?
 7915      (emit-asm "btst" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 7916(define (emit-bra lbl)
 7917  (asm-brel 24576 lbl)
 7918  (if ofile-asm? (emit-asm "bra" ofile-tab "L" lbl)))
 7919(define (emit-bcc lbl)
 7920  (asm-brel 25600 lbl)
 7921  (if ofile-asm? (emit-asm "bcc" ofile-tab "L" lbl)))
 7922(define (emit-bcs lbl)
 7923  (asm-brel 25856 lbl)
 7924  (if ofile-asm? (emit-asm "bcs" ofile-tab "L" lbl)))
 7925(define (emit-bhi lbl)
 7926  (asm-brel 25088 lbl)
 7927  (if ofile-asm? (emit-asm "bhi" ofile-tab "L" lbl)))
 7928(define (emit-bls lbl)
 7929  (asm-brel 25344 lbl)
 7930  (if ofile-asm? (emit-asm "bls" ofile-tab "L" lbl)))
 7931(define (emit-bmi lbl)
 7932  (asm-brel 27392 lbl)
 7933  (if ofile-asm? (emit-asm "bmi" ofile-tab "L" lbl)))
 7934(define (emit-bpl lbl)
 7935  (asm-brel 27136 lbl)
 7936  (if ofile-asm? (emit-asm "bpl" ofile-tab "L" lbl)))
 7937(define (emit-beq lbl)
 7938  (asm-brel 26368 lbl)
 7939  (if ofile-asm? (emit-asm "beq" ofile-tab "L" lbl)))
 7940(define (emit-bne lbl)
 7941  (asm-brel 26112 lbl)
 7942  (if ofile-asm? (emit-asm "bne" ofile-tab "L" lbl)))
 7943(define (emit-blt lbl)
 7944  (asm-brel 27904 lbl)
 7945  (if ofile-asm? (emit-asm "blt" ofile-tab "L" lbl)))
 7946(define (emit-bgt lbl)
 7947  (asm-brel 28160 lbl)
 7948  (if ofile-asm? (emit-asm "bgt" ofile-tab "L" lbl)))
 7949(define (emit-ble lbl)
 7950  (asm-brel 28416 lbl)
 7951  (if ofile-asm? (emit-asm "ble" ofile-tab "L" lbl)))
 7952(define (emit-bge lbl)
 7953  (asm-brel 27648 lbl)
 7954  (if ofile-asm? (emit-asm "bge" ofile-tab "L" lbl)))
 7955(define (emit-dbra dreg lbl)
 7956  (asm-word (+ 20936 dreg))
 7957  (asm-wrel lbl 0)
 7958  (if ofile-asm? (emit-asm "dbra" ofile-tab (opnd-str dreg) ",L" lbl)))
 7959(define (emit-trap num)
 7960  (asm-word (+ 20032 num))
 7961  (if ofile-asm? (emit-asm "trap" ofile-tab "#" num)))
 7962(define (emit-trap1 num args)
 7963  (asm-word (+ 20136 (areg-num table-reg)))
 7964  (asm-word (trap-offset num))
 7965  (let loop ((args args))
 7966    (if (not (null? args)) (begin (asm-word (car args)) (loop (cdr args)))))
 7967  (if ofile-asm?
 7968      (let ()
 7969        (define (words l)
 7970          (if (null? l) (list ")") (cons "," (cons (car l) (words (cdr l))))))
 7971        (apply emit-asm (cons "TRAP1(" (cons num (words args)))))))
 7972(define (emit-trap2 num args)
 7973  (asm-word (+ 20136 (areg-num table-reg)))
 7974  (asm-word (trap-offset num))
 7975  (asm-align 8 (modulo (- 4 (* (length args) 2)) 8))
 7976  (let loop ((args args))
 7977    (if (not (null? args)) (begin (asm-word (car args)) (loop (cdr args)))))
 7978  (if ofile-asm?
 7979      (let ()
 7980        (define (words l)
 7981          (if (null? l) (list ")") (cons "," (cons (car l) (words (cdr l))))))
 7982        (apply emit-asm (cons "TRAP2(" (cons num (words args)))))))
 7983(define (emit-trap3 num)
 7984  (asm-word (+ 20200 (areg-num table-reg)))
 7985  (asm-word (trap-offset num))
 7986  (if ofile-asm? (emit-asm "TRAP3(" num ")")))
 7987(define (emit-rts) (asm-word 20085) (if ofile-asm? (emit-asm "rts")))
 7988(define (emit-nop) (asm-word 20081) (if ofile-asm? (emit-asm "nop")))
 7989(define (emit-jmp opnd)
 7990  (asm-word (+ 20160 (opnd->mode/reg opnd)))
 7991  (opnd-ext-rd-long opnd)
 7992  (if ofile-asm? (emit-asm "jmp" ofile-tab (opnd-str opnd))))
 7993(define (emit-jmp-glob glob)
 7994  (asm-word 8814)
 7995  (asm-ref-glob-jump glob)
 7996  (asm-word 20177)
 7997  (if ofile-asm? (emit-asm "JMP_GLOB(" (glob-name glob) ")")))
 7998(define (emit-jmp-proc num offset)
 7999  (asm-word 20217)
 8000  (asm-proc-ref num offset)
 8001  (if ofile-asm? (emit-asm "JMP_PROC(" num "," offset ")")))
 8002(define (emit-jmp-prim val offset)
 8003  (asm-word 20217)
 8004  (asm-prim-ref val offset)
 8005  (if ofile-asm? (emit-asm "JMP_PRIM(" (proc-obj-name val) "," offset ")")))
 8006(define (emit-jsr opnd)
 8007  (asm-word (+ 20096 (opnd->mode/reg opnd)))
 8008  (opnd-ext-rd-long opnd)
 8009  (if ofile-asm? (emit-asm "jsr" ofile-tab (opnd-str opnd))))
 8010(define (emit-word n)
 8011  (asm-word n)
 8012  (if ofile-asm? (emit-asm ".word" ofile-tab n)))
 8013(define (emit-label lbl)
 8014  (asm-label lbl #f)
 8015  (if ofile-asm? (emit-asm* "L" lbl ":")))
 8016(define (emit-label-subproc lbl parent-lbl label-descr)
 8017  (asm-align 8 0)
 8018  (asm-wrel parent-lbl (- 32768 type-procedure))
 8019  (asm-label lbl label-descr)
 8020  (if ofile-asm?
 8021      (begin (emit-asm "SUBPROC(L" parent-lbl ")") (emit-asm* "L" lbl ":"))))
 8022(define (emit-label-return lbl parent-lbl fs link label-descr)
 8023  (asm-align 8 4)
 8024  (asm-word (* fs 4))
 8025  (asm-word (* (- fs link) 4))
 8026  (asm-wrel parent-lbl (- 32768 type-procedure))
 8027  (asm-label lbl label-descr)
 8028  (if ofile-asm?
 8029      (begin
 8030        (emit-asm "RETURN(L" parent-lbl "," fs "," link ")")
 8031        (emit-asm* "L" lbl ":"))))
 8032(define (emit-label-task-return lbl parent-lbl fs link label-descr)
 8033  (asm-align 8 4)
 8034  (asm-word (+ 32768 (* fs 4)))
 8035  (asm-word (* (- fs link) 4))
 8036  (asm-wrel parent-lbl (- 32768 type-procedure))
 8037  (asm-label lbl label-descr)
 8038  (if ofile-asm?
 8039      (begin
 8040        (emit-asm "TASK_RETURN(L" parent-lbl "," fs "," link ")")
 8041        (emit-asm* "L" lbl ":"))))
 8042(define (emit-lbl-ptr lbl)
 8043  (asm-wrel lbl 0)
 8044  (if ofile-asm? (emit-asm "LBL_PTR(L" lbl ")")))
 8045(define (emit-set-glob glob)
 8046  (asm-set-glob glob)
 8047  (if ofile-asm? (emit-asm "SET_GLOB(" (glob-name glob) ")")))
 8048(define (emit-const obj)
 8049  (let ((n (pos-in-list obj (queue->list asm-const-queue))))
 8050    (if n
 8051        (make-pcr const-lbl (* n 4))
 8052        (let ((m (length (queue->list asm-const-queue))))
 8053          (queue-put! asm-const-queue obj)
 8054          (make-pcr const-lbl (* m 4))))))
 8055(define (emit-stat stat)
 8056  (asm-word 21177)
 8057  (asm-stat stat)
 8058  (if ofile-asm? (emit-asm "STAT(" stat ")")))
 8059(define (emit-asm . l) (asm-comment (cons ofile-tab l)))
 8060(define (emit-asm* . l) (asm-comment l))
 8061(define (emit-muls.l opnd1 opnd2)
 8062  (asm-m68020-proc)
 8063  (asm-word (+ 19456 (opnd->mode/reg opnd1)))
 8064  (asm-word (+ 2048 (* (dreg-num opnd2) 4096)))
 8065  (opnd-ext-rd-long opnd1)
 8066  (if ofile-asm?
 8067      (emit-asm "mulsl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 8068(define (emit-divsl.l opnd1 opnd2 opnd3)
 8069  (asm-m68020-proc)
 8070  (asm-word (+ 19520 (opnd->mode/reg opnd1)))
 8071  (asm-word (+ 2048 (* (dreg-num opnd3) 4096) (dreg-num opnd2)))
 8072  (opnd-ext-rd-long opnd1)
 8073  (if ofile-asm?
 8074      (emit-asm
 8075       "divsll"
 8076       ofile-tab
 8077       (opnd-str opnd1)
 8078       ","
 8079       (opnd-str opnd2)
 8080       ":"
 8081       (opnd-str opnd3))))
 8082(define (emit-fint.dx opnd1 opnd2) (emit-fop.dx "int" 1 opnd1 opnd2))
 8083(define (emit-fsinh.dx opnd1 opnd2) (emit-fop.dx "sinh" 2 opnd1 opnd2))
 8084(define (emit-fintrz.dx opnd1 opnd2) (emit-fop.dx "intrz" 3 opnd1 opnd2))
 8085(define (emit-fsqrt.dx opnd1 opnd2) (emit-fop.dx "sqrt" 4 opnd1 opnd2))
 8086(define (emit-flognp1.dx opnd1 opnd2) (emit-fop.dx "lognp1" 6 opnd1 opnd2))
 8087(define (emit-fetoxm1.dx opnd1 opnd2) (emit-fop.dx "etoxm1" 8 opnd1 opnd2))
 8088(define (emit-ftanh.dx opnd1 opnd2) (emit-fop.dx "tanh" 9 opnd1 opnd2))
 8089(define (emit-fatan.dx opnd1 opnd2) (emit-fop.dx "atan" 10 opnd1 opnd2))
 8090(define (emit-fasin.dx opnd1 opnd2) (emit-fop.dx "asin" 12 opnd1 opnd2))
 8091(define (emit-fatanh.dx opnd1 opnd2) (emit-fop.dx "atanh" 13 opnd1 opnd2))
 8092(define (emit-fsin.dx opnd1 opnd2) (emit-fop.dx "sin" 14 opnd1 opnd2))
 8093(define (emit-ftan.dx opnd1 opnd2) (emit-fop.dx "tan" 15 opnd1 opnd2))
 8094(define (emit-fetox.dx opnd1 opnd2) (emit-fop.dx "etox" 16 opnd1 opnd2))
 8095(define (emit-ftwotox.dx opnd1 opnd2) (emit-fop.dx "twotox" 17 opnd1 opnd2))
 8096(define (emit-ftentox.dx opnd1 opnd2) (emit-fop.dx "tentox" 18 opnd1 opnd2))
 8097(define (emit-flogn.dx opnd1 opnd2) (emit-fop.dx "logn" 20 opnd1 opnd2))
 8098(define (emit-flog10.dx opnd1 opnd2) (emit-fop.dx "log10" 21 opnd1 opnd2))
 8099(define (emit-flog2.dx opnd1 opnd2) (emit-fop.dx "log2" 22 opnd1 opnd2))
 8100(define (emit-fabs.dx opnd1 opnd2) (emit-fop.dx "abs" 24 opnd1 opnd2))
 8101(define (emit-fcosh.dx opnd1 opnd2) (emit-fop.dx "cosh" 25 opnd1 opnd2))
 8102(define (emit-fneg.dx opnd1 opnd2) (emit-fop.dx "neg" 26 opnd1 opnd2))
 8103(define (emit-facos.dx opnd1 opnd2) (emit-fop.dx "acos" 28 opnd1 opnd2))
 8104(define (emit-fcos.dx opnd1 opnd2) (emit-fop.dx "cos" 29 opnd1 opnd2))
 8105(define (emit-fgetexp.dx opnd1 opnd2) (emit-fop.dx "getexp" 30 opnd1 opnd2))
 8106(define (emit-fgetman.dx opnd1 opnd2) (emit-fop.dx "getman" 31 opnd1 opnd2))
 8107(define (emit-fdiv.dx opnd1 opnd2) (emit-fop.dx "div" 32 opnd1 opnd2))
 8108(define (emit-fmod.dx opnd1 opnd2) (emit-fop.dx "mod" 33 opnd1 opnd2))
 8109(define (emit-fadd.dx opnd1 opnd2) (emit-fop.dx "add" 34 opnd1 opnd2))
 8110(define (emit-fmul.dx opnd1 opnd2) (emit-fop.dx "mul" 35 opnd1 opnd2))
 8111(define (emit-fsgldiv.dx opnd1 opnd2) (emit-fop.dx "sgldiv" 36 opnd1 opnd2))
 8112(define (emit-frem.dx opnd1 opnd2) (emit-fop.dx "rem" 37 opnd1 opnd2))
 8113(define (emit-fscale.dx opnd1 opnd2) (emit-fop.dx "scale" 38 opnd1 opnd2))
 8114(define (emit-fsglmul.dx opnd1 opnd2) (emit-fop.dx "sglmul" 39 opnd1 opnd2))
 8115(define (emit-fsub.dx opnd1 opnd2) (emit-fop.dx "sub" 40 opnd1 opnd2))
 8116(define (emit-fcmp.dx opnd1 opnd2) (emit-fop.dx "cmp" 56 opnd1 opnd2))
 8117(define (emit-fop.dx name code opnd1 opnd2)
 8118  (asm-m68881-proc)
 8119  (asm-word (+ 61952 (opnd->mode/reg opnd1)))
 8120  (asm-word
 8121   (+ (if (freg? opnd1) (* (freg-num opnd1) 1024) 21504)
 8122      (* (freg-num opnd2) 128)
 8123      code))
 8124  (opnd-ext-rd-long opnd1)
 8125  (if ofile-asm?
 8126      (emit-asm
 8127       "f"
 8128       name
 8129       (if (freg? opnd1) "x" "d")
 8130       ofile-tab
 8131       (opnd-str opnd1)
 8132       ","
 8133       (opnd-str opnd2))))
 8134(define (emit-fmov.dx opnd1 opnd2)
 8135  (emit-fmov
 8136   (if (and (freg? opnd1) (freg? opnd2)) (* (freg-num opnd1) 1024) 21504)
 8137   opnd1
 8138   opnd2)
 8139  (if ofile-asm?
 8140      (emit-asm
 8141       (if (and (freg? opnd1) (freg? opnd2)) "fmovex" "fmoved")
 8142       ofile-tab
 8143       (opnd-str opnd1)
 8144       ","
 8145       (opnd-str opnd2))))
 8146(define (emit-fmov.l opnd1 opnd2)
 8147  (emit-fmov 16384 opnd1 opnd2)
 8148  (if ofile-asm?
 8149      (emit-asm "fmovel" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
 8150(define (emit-fmov code opnd1 opnd2)
 8151  (define (fmov code opnd1 opnd2)
 8152    (asm-m68881-proc)
 8153    (asm-word (+ 61952 (opnd->mode/reg opnd1)))
 8154    (asm-word (+ (* (freg-num opnd2) 128) code))
 8155    (opnd-ext-rd-long opnd1))
 8156  (if (freg? opnd2) (fmov code opnd1 opnd2) (fmov (+ code 8192) opnd2 opnd1)))
 8157(define (emit-fbeq lbl)
 8158  (asm-m68881-proc)
 8159  (asm-word 62081)
 8160  (asm-wrel lbl 0)
 8161  (if ofile-asm? (emit-asm "fbeq" ofile-tab "L" lbl)))
 8162(define (emit-fbne lbl)
 8163  (asm-m68881-proc)
 8164  (asm-word 62094)
 8165  (asm-wrel lbl 0)
 8166  (if ofile-asm? (emit-asm "fbne" ofile-tab "L" lbl)))
 8167(define (emit-fblt lbl)
 8168  (asm-m68881-proc)
 8169  (asm-word 62100)
 8170  (asm-wrel lbl 0)
 8171  (if ofile-asm? (emit-asm "fblt" ofile-tab "L" lbl)))
 8172(define (emit-fbgt lbl)
 8173  (asm-m68881-proc)
 8174  (asm-word 62098)
 8175  (asm-wrel lbl 0)
 8176  (if ofile-asm? (emit-asm "fbgt" ofile-tab "L" lbl)))
 8177(define (emit-fble lbl)
 8178  (asm-m68881-proc)
 8179  (asm-word 62101)
 8180  (asm-wrel lbl 0)
 8181  (if ofile-asm? (emit-asm "fble" ofile-tab "L" lbl)))
 8182(define (emit-fbge lbl)
 8183  (asm-m68881-proc)
 8184  (asm-word 62099)
 8185  (asm-wrel lbl 0)
 8186  (if ofile-asm? (emit-asm "fbge" ofile-tab "L" lbl)))
 8187(define (opnd->mode/reg opnd)
 8188  (cond ((disp? opnd) (+ 32 (disp-areg opnd)))
 8189        ((inx? opnd) (+ 40 (inx-areg opnd)))
 8190        ((pcr? opnd) 58)
 8191        ((imm? opnd) 60)
 8192        ((glob? opnd) (+ 32 table-reg))
 8193        ((freg? opnd) 0)
 8194        (else opnd)))
 8195(define (opnd->reg/mode opnd)
 8196  (let ((x (opnd->mode/reg opnd)))
 8197    (* (+ (* 8 (remainder x 8)) (quotient x 8)) 64)))
 8198(define (opnd-ext-rd-long opnd) (opnd-extension opnd #f #f))
 8199(define (opnd-ext-rd-word opnd) (opnd-extension opnd #f #t))
 8200(define (opnd-ext-wr-long opnd) (opnd-extension opnd #t #f))
 8201(define (opnd-ext-wr-word opnd) (opnd-extension opnd #t #t))
 8202(define (opnd-extension opnd write? word?)
 8203  (cond ((disp? opnd) (asm-word (disp-offset opnd)))
 8204        ((inx? opnd)
 8205         (asm-word
 8206          (+ (+ (* (inx-ireg opnd) 4096) 2048)
 8207             (modulo (inx-offset opnd) 256))))
 8208        ((pcr? opnd) (asm-wrel (pcr-lbl opnd) (pcr-offset opnd)))
 8209        ((imm? opnd)
 8210         (if word? (asm-word (imm-val opnd)) (asm-long (imm-val opnd))))
 8211        ((glob? opnd) (if write? (asm-set-glob opnd) (asm-ref-glob opnd)))))
 8212(define (opnd-str opnd)
 8213  (cond ((dreg? opnd)
 8214         (vector-ref
 8215          '#("d0" "d1" "d2" "d3" "d4" "d5" "d6" "d7")
 8216          (dreg-num opnd)))
 8217        ((areg? opnd)
 8218         (vector-ref
 8219          '#("a0" "a1" "a2" "a3" "a4" "a5" "a6" "sp")
 8220          (areg-num opnd)))
 8221        ((ind? opnd)
 8222         (vector-ref
 8223          '#("a0@" "a1@" "a2@" "a3@" "a4@" "a5@" "a6@" "sp@")
 8224          (areg-num (ind-areg opnd))))
 8225        ((pinc? opnd)
 8226         (vector-ref
 8227          '#("a0@+" "a1@+" "a2@+" "a3@+" "a4@+" "a5@+" "a6@+" "sp@+")
 8228          (areg-num (pinc-areg opnd))))
 8229        ((pdec? opnd)
 8230         (vector-ref
 8231          '#("a0@-" "a1@-" "a2@-" "a3@-" "a4@-" "a5@-" "a6@-" "sp@-")
 8232          (areg-num (pdec-areg opnd))))
 8233        ((disp? opnd)
 8234         (string-append
 8235          (opnd-str (disp-areg opnd))
 8236          "@("
 8237          (number->string (disp-offset opnd))
 8238          ")"))
 8239        ((inx? opnd)
 8240         (string-append
 8241          (opnd-str (inx-areg opnd))
 8242          "@("
 8243          (number->string (inx-offset opnd))
 8244          ","
 8245          (opnd-str (inx-ireg opnd))
 8246          ":l)"))
 8247        ((pcr? opnd)
 8248         (let ((lbl (pcr-lbl opnd)) (offs (pcr-offset opnd)))
 8249           (if (= offs 0)
 8250               (string-append "L" (number->string lbl))
 8251               (string-append
 8252                "L"
 8253                (number->string lbl)
 8254                "+"
 8255                (number->string offs)))))
 8256        ((imm? opnd) (string-append "#" (number->string (imm-val opnd))))
 8257        ((glob? opnd)
 8258         (string-append "GLOB(" (symbol->string (glob-name opnd)) ")"))
 8259        ((freg? opnd)
 8260         (vector-ref
 8261          '#("fp0" "fp1" "fp2" "fp3" "fp4" "fp5" "fp6" "fp7")
 8262          (freg-num opnd)))
 8263        ((reg-list? opnd)
 8264         (let loop ((l (reg-list-regs opnd)) (result "[") (sep ""))
 8265           (if (pair? l)
 8266               (loop (cdr l) (string-append result sep (opnd-str (car l))) "/")
 8267               (string-append result "]"))))
 8268        (else (compiler-internal-error "opnd-str, unknown 'opnd'" opnd))))
 8269(define (begin! info-port targ)
 8270  (set! return-reg (make-reg 0))
 8271  (target-end!-set! targ end!)
 8272  (target-dump-set! targ dump)
 8273  (target-nb-regs-set! targ nb-gvm-regs)
 8274  (target-prim-info-set! targ prim-info)
 8275  (target-label-info-set! targ label-info)
 8276  (target-jump-info-set! targ jump-info)
 8277  (target-proc-result-set! targ (make-reg 1))
 8278  (target-task-return-set! targ return-reg)
 8279  (set! *info-port* info-port)
 8280  '())
 8281(define (end!) '())
 8282(define *info-port* '())
 8283(define nb-gvm-regs 5)
 8284(define nb-arg-regs 3)
 8285(define pointer-size 4)
 8286(define prim-proc-table
 8287  (map (lambda (x)
 8288         (cons (string->canonical-symbol (car x))
 8289               (apply make-proc-obj (car x) #t #f (cdr x))))
 8290       prim-procs))
 8291(define (prim-info name)
 8292  (let ((x (assq name prim-proc-table))) (if x (cdr x) #f)))
 8293(define (get-prim-info name)
 8294  (let ((proc (prim-info (string->canonical-symbol name))))
 8295    (if proc
 8296        proc
 8297        (compiler-internal-error "get-prim-info, unknown primitive:" name))))
 8298(define (label-info min-args nb-parms rest? closed?)
 8299  (let ((nb-stacked (max 0 (- nb-parms nb-arg-regs))))
 8300    (define (location-of-parms i)
 8301      (if (> i nb-parms)
 8302          '()
 8303          (cons (cons i
 8304                      (if (> i nb-stacked)
 8305                          (make-reg (- i nb-stacked))
 8306                          (make-stk i)))
 8307                (location-of-parms (+ i 1)))))
 8308    (let ((x (cons (cons 'return 0) (location-of-parms 1))))
 8309      (make-pcontext
 8310       nb-stacked
 8311       (if closed?
 8312           (cons (cons 'closure-env (make-reg (+ nb-arg-regs 1))) x)
 8313           x)))))
 8314(define (jump-info nb-args)
 8315  (let ((nb-stacked (max 0 (- nb-args nb-arg-regs))))
 8316    (define (location-of-args i)
 8317      (if (> i nb-args)
 8318          '()
 8319          (cons (cons i
 8320                      (if (> i nb-stacked)
 8321                          (make-reg (- i nb-stacked))
 8322                          (make-stk i)))
 8323                (location-of-args (+ i 1)))))
 8324    (make-pcontext
 8325     nb-stacked
 8326     (cons (cons 'return (make-reg 0)) (location-of-args 1)))))
 8327(define (closed-var-offset i) (+ (* i pointer-size) 2))
 8328(define (dump proc filename c-intf options)
 8329  (if *info-port*
 8330      (begin (display "Dumping:" *info-port*) (newline *info-port*)))
 8331  (set! ofile-asm? (memq 'asm options))
 8332  (set! ofile-stats? (memq 'stats options))
 8333  (set! debug-info? (memq 'debug options))
 8334  (set! object-queue (queue-empty))
 8335  (set! objects-dumped (queue-empty))
 8336  (ofile.begin! filename add-object)
 8337  (queue-put! object-queue proc)
 8338  (queue-put! objects-dumped proc)
 8339  (let loop ((index 0))
 8340    (if (not (queue-empty? object-queue))
 8341        (let ((obj (queue-get! object-queue)))
 8342          (dump-object obj index)
 8343          (loop (+ index 1)))))
 8344  (ofile.end!)
 8345  (if *info-port* (newline *info-port*))
 8346  (set! object-queue '())
 8347  (set! objects-dumped '()))
 8348(define debug-info? '())
 8349(define object-queue '())
 8350(define objects-dumped '())
 8351(define (add-object obj)
 8352  (if (and (proc-obj? obj) (not (proc-obj-code obj)))
 8353      #f
 8354      (let ((n (pos-in-list obj (queue->list objects-dumped))))
 8355        (if n
 8356            n
 8357            (let ((m (length (queue->list objects-dumped))))
 8358              (queue-put! objects-dumped obj)
 8359              (queue-put! object-queue obj)
 8360              m)))))
 8361(define (dump-object obj index)
 8362  (ofile-line "|------------------------------------------------------")
 8363  (case (obj-type obj)
 8364    ((pair) (dump-pair obj))
 8365    ((flonum) (dump-flonum obj))
 8366    ((subtyped)
 8367     (case (obj-subtype obj)
 8368       ((vector) (dump-vector obj))
 8369       ((symbol) (dump-symbol obj))
 8370;;       ((ratnum) (dump-ratnum obj))
 8371;;       ((cpxnum) (dump-cpxnum obj))
 8372       ((string) (dump-string obj))
 8373       ((bignum) (dump-bignum obj))
 8374       (else
 8375        (compiler-internal-error
 8376         "dump-object, can't dump object 'obj':"
 8377         obj))))
 8378    ((procedure) (dump-procedure obj))
 8379    (else
 8380     (compiler-internal-error "dump-object, can't dump object 'obj':" obj))))
 8381(define (dump-pair pair)
 8382  (ofile-long pair-prefix)
 8383  (ofile-ref (cdr pair))
 8384  (ofile-ref (car pair)))
 8385(define (dump-vector v)
 8386  (ofile-long (+ (* (vector-length v) 1024) (* subtype-vector 8)))
 8387  (let ((len (vector-length v)))
 8388    (let loop ((i 0))
 8389      (if (< i len) (begin (ofile-ref (vector-ref v i)) (loop (+ i 1)))))))
 8390(define (dump-symbol sym)
 8391  (compiler-internal-error "dump-symbol, can't dump SYMBOL type"))
 8392;;(define (dump-ratnum x)
 8393;;  (ofile-long (+ (* 2 1024) (* subtype-ratnum 8)))
 8394;;  (ofile-ref (numerator x))
 8395;;  (ofile-ref (denominator x)))
 8396;;(define (dump-cpxnum x)
 8397;;  (ofile-long (+ (* 2 1024) (* subtype-cpxnum 8)))
 8398;;  (ofile-ref (real-part x))
 8399;;  (ofile-ref (imag-part x)))
 8400(define (dump-string s)
 8401  (ofile-long (+ (* (+ (string-length s) 1) 256) (* subtype-string 8)))
 8402  (let ((len (string-length s)))
 8403    (define (ref i) (if (>= i len) 0 (character-encoding (string-ref s i))))
 8404    (let loop ((i 0))
 8405      (if (<= i len)
 8406          (begin
 8407            (ofile-word (+ (* (ref i) 256) (ref (+ i 1))))
 8408            (loop (+ i 2)))))))
 8409(define (dump-flonum x)
 8410  (let ((bits (flonum->bits x)))
 8411    (ofile-long flonum-prefix)
 8412    (ofile-long (quotient bits 4294967296))
 8413    (ofile-long (modulo bits 4294967296))))
 8414(define (flonum->inexact-exponential-format x)
 8415  (define (exp-form-pos x y i)
 8416    (let ((i*2 (+ i i)))
 8417      (let ((z (if (and (not (< flonum-e-bias i*2)) (not (< x y)))
 8418                   (exp-form-pos x (* y y) i*2)
 8419                   (cons x 0))))
 8420        (let ((a (car z)) (b (cdr z)))
 8421          (let ((i+b (+ i b)))
 8422            (if (and (not (< flonum-e-bias i+b)) (not (< a y)))
 8423                (begin (set-car! z (/ a y)) (set-cdr! z i+b)))
 8424            z)))))
 8425  (define (exp-form-neg x y i)
 8426    (let ((i*2 (+ i i)))
 8427      (let ((z (if (and (< i*2 flonum-e-bias-minus-1) (< x y))
 8428                   (exp-form-neg x (* y y) i*2)
 8429                   (cons x 0))))
 8430        (let ((a (car z)) (b (cdr z)))
 8431          (let ((i+b (+ i b)))
 8432            (if (and (< i+b flonum-e-bias-minus-1) (< a y))
 8433                (begin (set-car! z (/ a y)) (set-cdr! z i+b)))
 8434            z)))))
 8435  (define (exp-form x)
 8436    (if (< x inexact-+1)
 8437        (let ((z (exp-form-neg x inexact-+1/2 1)))
 8438          (set-car! z (* inexact-+2 (car z)))
 8439          (set-cdr! z (- -1 (cdr z)))
 8440          z)
 8441        (exp-form-pos x inexact-+2 1)))
 8442  (if (negative? x)
 8443      (let ((z (exp-form (- inexact-0 x))))
 8444        (set-car! z (- inexact-0 (car z)))
 8445        z)
 8446      (exp-form x)))
 8447(define (flonum->exact-exponential-format x)
 8448  (let ((z (flonum->inexact-exponential-format x)))
 8449    (let ((y (car z)))
 8450      (cond ((not (< y inexact-+2))
 8451             (set-car! z flonum-+m-min)
 8452             (set-cdr! z flonum-e-bias-plus-1))
 8453            ((not (< inexact--2 y))
 8454             (set-car! z flonum--m-min)
 8455             (set-cdr! z flonum-e-bias-plus-1))
 8456            (else
 8457             (set-car!
 8458              z
 8459              (truncate (inexact->exact (* (car z) inexact-m-min))))))
 8460      (set-cdr! z (- (cdr z) flonum-m-bits))
 8461      z)))
 8462(define (flonum->bits x)
 8463  (define (bits a b)
 8464    (if (< a flonum-+m-min)
 8465        a
 8466        (+ (- a flonum-+m-min)
 8467           (* (+ (+ b flonum-m-bits) flonum-e-bias) flonum-+m-min))))
 8468  (let ((z (flonum->exact-exponential-format x)))
 8469    (let ((a (car z)) (b (cdr z)))
 8470      (if (negative? a) (+ flonum-sign-bit (bits (- 0 a) b)) (bits a b)))))
 8471(define flonum-m-bits 52)
 8472(define flonum-e-bits 11)
 8473(define flonum-sign-bit 9223372036854775808)
 8474(define flonum-+m-min 4503599627370496)
 8475(define flonum--m-min -4503599627370496)
 8476(define flonum-e-bias 1023)
 8477(define flonum-e-bias-plus-1 1024)
 8478(define flonum-e-bias-minus-1 1022)
 8479(define inexact-m-min (exact->inexact flonum-+m-min))
 8480(define inexact-+2 (exact->inexact 2))
 8481(define inexact--2 (exact->inexact -2))
 8482(define inexact-+1 (exact->inexact 1))
 8483(define inexact-+1/2 (/ (exact->inexact 1) (exact->inexact 2)))
 8484(define inexact-0 (exact->inexact 0))
 8485(define (dump-bignum x)
 8486  (define radix 16384)
 8487  (define (integer->digits n)
 8488    (if (= n 0)
 8489        '()
 8490        (cons (remainder n radix) (integer->digits (quotient n radix)))))
 8491  (let ((l (integer->digits (abs x))))
 8492    (ofile-long (+ (* (+ (length l) 1) 512) (* subtype-bignum 8)))
 8493    (if (< x 0) (ofile-word 0) (ofile-word 1))
 8494    (for-each ofile-word l)))
 8495(define (dump-procedure proc)
 8496  (let ((bbs (proc-obj-code proc)))
 8497    (set! entry-lbl-num (bbs-entry-lbl-num bbs))
 8498    (set! label-counter (bbs-lbl-counter bbs))
 8499    (set! var-descr-queue (queue-empty))
 8500    (set! first-class-label-queue (queue-empty))
 8501    (set! deferred-code-queue (queue-empty))
 8502    (if *info-port*
 8503        (begin
 8504          (display "  #[" *info-port*)
 8505          (if (proc-obj-primitive? proc)
 8506              (display "primitive " *info-port*)
 8507              (display "procedure " *info-port*))
 8508          (display (proc-obj-name proc) *info-port*)
 8509          (display "]" *info-port*)))
 8510    (if (proc-obj-primitive? proc)
 8511        (ofile-prim-proc (proc-obj-name proc))
 8512        (ofile-user-proc))
 8513    (asm.begin!)
 8514    (let loop ((prev-bb #f) (prev-gvm-instr #f) (l (bbs->code-list bbs)))
 8515      (if (not (null? l))
 8516          (let ((pres-bb (code-bb (car l)))
 8517                (pres-gvm-instr (code-gvm-instr (car l)))
 8518                (pres-slots-needed (code-slots-needed (car l)))
 8519                (next-gvm-instr
 8520                 (if (null? (cdr l)) #f (code-gvm-instr (cadr l)))))
 8521            (if ofile-asm? (asm-comment (car l)))
 8522            (gen-gvm-instr
 8523             prev-gvm-instr
 8524             pres-gvm-instr
 8525             next-gvm-instr
 8526             pres-slots-needed)
 8527            (loop pres-bb pres-gvm-instr (cdr l)))))
 8528    (asm.end!
 8529     (if debug-info?
 8530         (vector (lst->vector (queue->list first-class-label-queue))
 8531                 (lst->vector (queue->list var-descr-queue)))
 8532         #f))
 8533    (if *info-port* (newline *info-port*))
 8534    (set! var-descr-queue '())
 8535    (set! first-class-label-queue '())
 8536    (set! deferred-code-queue '())
 8537    (set! instr-source '())
 8538    (set! entry-frame '())
 8539    (set! exit-frame '())))
 8540(define label-counter (lambda () 0))
 8541(define entry-lbl-num '())
 8542(define var-descr-queue '())
 8543(define first-class-label-queue '())
 8544(define deferred-code-queue '())
 8545(define instr-source '())
 8546(define entry-frame '())
 8547(define exit-frame '())
 8548(define (defer-code! thunk) (queue-put! deferred-code-queue thunk))
 8549(define (gen-deferred-code!)
 8550  (let loop ()
 8551    (if (not (queue-empty? deferred-code-queue))
 8552        (let ((thunk (queue-get! deferred-code-queue))) (thunk) (loop)))))
 8553(define (add-var-descr! descr)
 8554  (define (index x l)
 8555    (let loop ((l l) (i 0))
 8556      (cond ((not (pair? l)) #f)
 8557            ((equal? (car l) x) i)
 8558            (else (loop (cdr l) (+ i 1))))))
 8559  (let ((n (index descr (queue->list var-descr-queue))))
 8560    (if n
 8561        n
 8562        (let ((m (length (queue->list var-descr-queue))))
 8563          (queue-put! var-descr-queue descr)
 8564          m))))
 8565(define (add-first-class-label! source slots frame)
 8566  (let loop ((i 0) (l1 slots) (l2 '()))
 8567    (if (pair? l1)
 8568        (let ((var (car l1)))
 8569          (let ((x (frame-live? var frame)))
 8570            (if (and x (or (pair? x) (not (temp-var? x))))
 8571                (let ((descr-index
 8572                       (add-var-descr!
 8573                        (if (pair? x)
 8574                            (map (lambda (y) (add-var-descr! (var-name y))) x)
 8575                            (var-name x)))))
 8576                  (loop (+ i 1)
 8577                        (cdr l1)
 8578                        (cons (+ (* i 16384) descr-index) l2)))
 8579                (loop (+ i 1) (cdr l1) l2))))
 8580        (let ((label-descr (lst->vector (cons 0 (cons source l2)))))
 8581          (queue-put! first-class-label-queue label-descr)
 8582          label-descr))))
 8583(define (gen-gvm-instr prev-gvm-instr gvm-instr next-gvm-instr sn)
 8584  (set! instr-source (comment-get (gvm-instr-comment gvm-instr) 'source))
 8585  (set! exit-frame (gvm-instr-frame gvm-instr))
 8586  (set! entry-frame (and prev-gvm-instr (gvm-instr-frame prev-gvm-instr)))
 8587  (case (gvm-instr-type gvm-instr)
 8588    ((label)
 8589     (set! entry-frame exit-frame)
 8590     (set! current-fs (frame-size exit-frame))
 8591     (case (label-type gvm-instr)
 8592       ((simple) (gen-label-simple (label-lbl-num gvm-instr) sn))
 8593       ((entry)
 8594        (gen-label-entry
 8595         (label-lbl-num gvm-instr)
 8596         (label-entry-nb-parms gvm-instr)
 8597         (label-entry-min gvm-instr)
 8598         (label-entry-rest? gvm-instr)
 8599         (label-entry-closed? gvm-instr)
 8600         sn))
 8601       ((return) (gen-label-return (label-lbl-num gvm-instr) sn))
 8602       ((task-entry) (gen-label-task-entry (label-lbl-num gvm-instr) sn))
 8603       ((task-return) (gen-label-task-return (label-lbl-num gvm-instr) sn))
 8604       (else (compiler-internal-error "gen-gvm-instr, unknown label type"))))
 8605    ((apply)
 8606     (gen-apply
 8607      (apply-prim gvm-instr)
 8608      (apply-opnds gvm-instr)
 8609      (apply-loc gvm-instr)
 8610      sn))
 8611    ((copy) (gen-copy (copy-opnd gvm-instr) (copy-loc gvm-instr) sn))
 8612    ((close) (gen-close (close-parms gvm-instr) sn))
 8613    ((ifjump)
 8614     (gen-ifjump
 8615      (ifjump-test gvm-instr)
 8616      (ifjump-opnds gvm-instr)
 8617      (ifjump-true gvm-instr)
 8618      (ifjump-false gvm-instr)
 8619      (ifjump-poll? gvm-instr)
 8620      (if (and next-gvm-instr
 8621               (memq (label-type next-gvm-instr) '(simple task-entry)))
 8622          (label-lbl-num next-gvm-instr)
 8623          #f)))
 8624    ((jump)
 8625     (gen-jump
 8626      (jump-opnd gvm-instr)
 8627      (jump-nb-args gvm-instr)
 8628      (jump-poll? gvm-instr)
 8629      (if (and next-gvm-instr
 8630               (memq (label-type next-gvm-instr) '(simple task-entry)))
 8631          (label-lbl-num next-gvm-instr)
 8632          #f)))
 8633    (else
 8634     (compiler-internal-error
 8635      "gen-gvm-instr, unknown 'gvm-instr':"
 8636      gvm-instr))))
 8637(define (reg-in-opnd68 opnd)
 8638  (cond ((dreg? opnd) opnd)
 8639        ((areg? opnd) opnd)
 8640        ((ind? opnd) (ind-areg opnd))
 8641        ((pinc? opnd) (pinc-areg opnd))
 8642        ((pdec? opnd) (pdec-areg opnd))
 8643        ((disp? opnd) (disp-areg opnd))
 8644        ((inx? opnd) (inx-ireg opnd))
 8645        (else #f)))
 8646(define (temp-in-opnd68 opnd)
 8647  (let ((reg (reg-in-opnd68 opnd)))
 8648    (if reg
 8649        (cond ((identical-opnd68? reg dtemp1) reg)
 8650              ((identical-opnd68? reg atemp1) reg)
 8651              ((identical-opnd68? reg atemp2) reg)
 8652              (else #f))
 8653        #f)))
 8654(define (pick-atemp keep)
 8655  (if (and keep (identical-opnd68? keep atemp1)) atemp2 atemp1))
 8656(define return-reg '())
 8657(define max-nb-args 1024)
 8658(define heap-allocation-fudge (* pointer-size (+ (* 2 max-nb-args) 1024)))
 8659(define intr-flag 0)
 8660(define ltq-tail 1)
 8661(define ltq-head 2)
 8662(define heap-lim 12)
 8663(define closure-lim 17)
 8664(define closure-ptr 18)
 8665(define intr-flag-slot (make-disp* pstate-reg (* pointer-size intr-flag)))
 8666(define ltq-tail-slot (make-disp* pstate-reg (* pointer-size ltq-tail)))
 8667(define ltq-head-slot (make-disp* pstate-reg (* pointer-size ltq-head)))
 8668(define heap-lim-slot (make-disp* pstate-reg (* pointer-size heap-lim)))
 8669(define closure-lim-slot (make-disp* pstate-reg (* pointer-size closure-lim)))
 8670(define closure-ptr-slot (make-disp* pstate-reg (* pointer-size closure-ptr)))
 8671(define touch-trap 1)
 8672(define non-proc-jump-trap 6)
 8673(define rest-params-trap 7)
 8674(define rest-params-closed-trap 8)
 8675(define wrong-nb-arg1-trap 9)
 8676(define wrong-nb-arg1-closed-trap 10)
 8677(define wrong-nb-arg2-trap 11)
 8678(define wrong-nb-arg2-closed-trap 12)
 8679(define heap-alloc1-trap 13)
 8680(define heap-alloc2-trap 14)
 8681(define closure-alloc-trap 15)
 8682(define intr-trap 24)
 8683(define cache-line-length 16)
 8684(define polling-intermittency '())
 8685(set! polling-intermittency 10)
 8686(define (stat-clear!) (set! *stats* (cons 0 '())))
 8687(define (stat-dump!) (emit-stat (cdr *stats*)))
 8688(define (stat-add! bin count)
 8689  (define (add! stats bin count)
 8690    (set-car! stats (+ (car stats) count))
 8691    (if (not (null? bin))
 8692        (let ((x (assoc (car bin) (cdr stats))))
 8693          (if x
 8694              (add! (cdr x) (cdr bin) count)
 8695              (begin
 8696                (set-cdr! stats (cons (list (car bin) 0) (cdr stats)))
 8697                (add! (cdadr stats) (cdr bin) count))))))
 8698  (add! *stats* bin count))
 8699(define (fetch-stat-add! gvm-opnd) (opnd-stat-add! 'fetch gvm-opnd))
 8700(define (store-stat-add! gvm-opnd) (opnd-stat-add! 'store gvm-opnd))
 8701(define (jump-stat-add! gvm-opnd) (opnd-stat-add! 'jump gvm-opnd))
 8702(define (opnd-stat-add! type opnd)
 8703  (cond ((reg? opnd) (stat-add! (list 'gvm-opnd 'reg type (reg-num opnd)) 1))
 8704        ((stk? opnd) (stat-add! (list 'gvm-opnd 'stk type) 1))
 8705        ((glo? opnd) (stat-add! (list 'gvm-opnd 'glo type (glo-name opnd)) 1))
 8706        ((clo? opnd)
 8707         (stat-add! (list 'gvm-opnd 'clo type) 1)
 8708         (fetch-stat-add! (clo-base opnd)))
 8709        ((lbl? opnd) (stat-add! (list 'gvm-opnd 'lbl type) 1))
 8710        ((obj? opnd)
 8711         (let ((val (obj-val opnd)))
 8712           (if (number? val)
 8713               (stat-add! (list 'gvm-opnd 'obj type val) 1)
 8714               (stat-add! (list 'gvm-opnd 'obj type (obj-type val)) 1))))
 8715        (else
 8716         (compiler-internal-error "opnd-stat-add!, unknown 'opnd':" opnd))))
 8717(define (opnd-stat opnd)
 8718  (cond ((reg? opnd) 'reg)
 8719        ((stk? opnd) 'stk)
 8720        ((glo? opnd) 'glo)
 8721        ((clo? opnd) 'clo)
 8722        ((lbl? opnd) 'lbl)
 8723        ((obj? opnd) 'obj)
 8724        (else (compiler-internal-error "opnd-stat, unknown 'opnd':" opnd))))
 8725(define *stats* '())
 8726(define (move-opnd68-to-loc68 opnd loc)
 8727  (if (not (identical-opnd68? opnd loc))
 8728      (if (imm? opnd)
 8729          (move-n-to-loc68 (imm-val opnd) loc)
 8730          (emit-move.l opnd loc))))
 8731(define (move-obj-to-loc68 obj loc)
 8732  (let ((n (obj-encoding obj)))
 8733    (if n (move-n-to-loc68 n loc) (emit-move.l (emit-const obj) loc))))
 8734(define (move-n-to-loc68 n loc)
 8735  (cond ((= n bits-null) (emit-move.l null-reg loc))
 8736        ((= n bits-false) (emit-move.l false-reg loc))
 8737        ((and (dreg? loc) (>= n -128) (<= n 127)) (emit-moveq n loc))
 8738        ((and (areg? loc) (>= n -32768) (<= n 32767))
 8739         (emit-move.w (make-imm n) loc))
 8740        ((and (identical-opnd68? loc pdec-sp) (>= n -32768) (<= n 32767))
 8741         (emit-pea* n))
 8742        ((= n 0) (emit-clr.l loc))
 8743        ((and (not (and (inx? loc) (= (inx-ireg loc) dtemp1)))
 8744              (>= n -128)
 8745              (<= n 127))
 8746         (emit-moveq n dtemp1)
 8747         (emit-move.l dtemp1 loc))
 8748        (else (emit-move.l (make-imm n) loc))))
 8749(define (add-n-to-loc68 n loc)
 8750  (if (not (= n 0))
 8751      (cond ((and (>= n -8) (<= n 8))
 8752             (if (> n 0) (emit-addq.l n loc) (emit-subq.l (- n) loc)))
 8753            ((and (areg? loc) (>= n -32768) (<= n 32767))
 8754             (emit-lea (make-disp loc n) loc))
 8755            ((and (not (identical-opnd68? loc dtemp1)) (>= n -128) (<= n 128))
 8756             (emit-moveq (- (abs n)) dtemp1)
 8757             (if (> n 0) (emit-sub.l dtemp1 loc) (emit-add.l dtemp1 loc)))
 8758            (else (emit-add.l (make-imm n) loc)))))
 8759(define (power-of-2 n)
 8760  (let loop ((i 0) (k 1))
 8761    (cond ((= k n) i) ((> k n) #f) (else (loop (+ i 1) (* k 2))))))
 8762(define (mul-n-to-reg68 n reg)
 8763  (if (= n 0)
 8764      (emit-moveq 0 reg)
 8765      (let ((abs-n (abs n)))
 8766        (if (= abs-n 1)
 8767            (if (< n 0) (emit-neg.l reg))
 8768            (let ((shift (power-of-2 abs-n)))
 8769              (if shift
 8770                  (let ((m (min shift 32)))
 8771                    (if (or (<= m 8) (identical-opnd68? reg dtemp1))
 8772                        (let loop ((i m))
 8773                          (if (> i 0)
 8774                              (begin
 8775                                (emit-asl.l (make-imm (min i 8)) reg)
 8776                                (loop (- i 8)))))
 8777                        (begin (emit-moveq m dtemp1) (emit-asl.l dtemp1 reg)))
 8778                    (if (< n 0) (emit-neg.l reg)))
 8779                  (emit-muls.l (make-imm n) reg)))))))
 8780(define (div-n-to-reg68 n reg)
 8781  (let ((abs-n (abs n)))
 8782    (if (= abs-n 1)
 8783        (if (< n 0) (emit-neg.l reg))
 8784        (let ((shift (power-of-2 abs-n)))
 8785          (if shift
 8786              (let ((m (min shift 32)) (lbl (new-lbl!)))
 8787                (emit-move.l reg reg)
 8788                (emit-bpl lbl)
 8789                (add-n-to-loc68 (* (- abs-n 1) 8) reg)
 8790                (emit-label lbl)
 8791                (if (or (<= m 8) (identical-opnd68? reg dtemp1))
 8792                    (let loop ((i m))
 8793                      (if (> i 0)
 8794                          (begin
 8795                            (emit-asr.l (make-imm (min i 8)) reg)
 8796                            (loop (- i 8)))))
 8797                    (begin (emit-moveq m dtemp1) (emit-asr.l dtemp1 reg)))
 8798                (if (< n 0) (emit-neg.l reg)))
 8799              (emit-divsl.l (make-imm n) reg reg))))))
 8800(define (cmp-n-to-opnd68 n opnd)
 8801  (cond ((= n bits-null) (emit-cmp.l opnd null-reg) #f)
 8802        ((= n bits-false) (emit-cmp.l opnd false-reg) #f)
 8803        ((or (pcr? opnd) (imm? opnd))
 8804         (if (= n 0)
 8805             (begin (emit-move.l opnd dtemp1) #t)
 8806             (begin
 8807               (move-opnd68-to-loc68 opnd atemp1)
 8808               (if (and (>= n -32768) (<= n 32767))
 8809                   (emit-cmp.w (make-imm n) atemp1)
 8810                   (emit-cmp.l (make-imm n) atemp1))
 8811               #t)))
 8812        ((= n 0) (emit-move.l opnd dtemp1) #t)
 8813        ((and (>= n -128) (<= n 127) (not (identical-opnd68? opnd dtemp1)))
 8814         (emit-moveq n dtemp1)
 8815         (emit-cmp.l opnd dtemp1)
 8816         #f)
 8817        (else (emit-cmp.l (make-imm n) opnd) #t)))
 8818(define current-fs '())
 8819(define (adjust-current-fs n) (set! current-fs (+ current-fs n)))
 8820(define (new-lbl!) (label-counter))
 8821(define (needed? loc sn) (and loc (if (stk? loc) (<= (stk-num loc) sn) #t)))
 8822(define (sn-opnd opnd sn)
 8823  (cond ((stk? opnd) (max (stk-num opnd) sn))
 8824        ((clo? opnd) (sn-opnd (clo-base opnd) sn))
 8825        (else sn)))
 8826(define (sn-opnds opnds sn)
 8827  (if (null? opnds) sn (sn-opnd (car opnds) (sn-opnds (cdr opnds) sn))))
 8828(define (sn-opnd68 opnd sn)
 8829  (cond ((and (disp*? opnd) (identical-opnd68? (disp*-areg opnd) sp-reg))
 8830         (max (disp*-offset opnd) sn))
 8831        ((identical-opnd68? opnd pdec-sp) (max (+ current-fs 1) sn))
 8832        ((identical-opnd68? opnd pinc-sp) (max current-fs sn))
 8833        (else sn)))
 8834(define (resize-frame n)
 8835  (let ((x (- n current-fs)))
 8836    (adjust-current-fs x)
 8837    (add-n-to-loc68 (* (- pointer-size) x) sp-reg)))
 8838(define (shrink-frame n)
 8839  (cond ((< n current-fs) (resize-frame n))
 8840        ((> n current-fs)
 8841         (compiler-internal-error "shrink-frame, can't increase frame size"))))
 8842(define (make-top-of-frame n sn)
 8843  (if (and (< n current-fs) (>= n sn)) (resize-frame n)))
 8844(define (make-top-of-frame-if-stk-opnd68 opnd sn)
 8845  (if (frame-base-rel? opnd)
 8846      (make-top-of-frame (frame-base-rel-slot opnd) sn)))
 8847(define (make-top-of-frame-if-stk-opnds68 opnd1 opnd2 sn)
 8848  (if (frame-base-rel? opnd1)
 8849      (let ((slot1 (frame-base-rel-slot opnd1)))
 8850        (if (frame-base-rel? opnd2)
 8851            (make-top-of-frame (max (frame-base-rel-slot opnd2) slot1) sn)
 8852            (make-top-of-frame slot1 sn)))
 8853      (if (frame-base-rel? opnd2)
 8854          (make-top-of-frame (frame-base-rel-slot opnd2) sn))))
 8855(define (opnd68->true-opnd68 opnd sn)
 8856  (if (frame-base-rel? opnd)
 8857      (let ((slot (frame-base-rel-slot opnd)))
 8858        (cond ((> slot current-fs) (adjust-current-fs 1) pdec-sp)
 8859              ((and (= slot current-fs) (< sn current-fs))
 8860               (adjust-current-fs -1)
 8861               pinc-sp)
 8862              (else (make-disp* sp-reg (* pointer-size (- current-fs slot))))))
 8863      opnd))
 8864(define (move-opnd68-to-any-areg opnd keep sn)
 8865  (if (areg? opnd)
 8866      opnd
 8867      (let ((areg (pick-atemp keep)))
 8868        (make-top-of-frame-if-stk-opnd68 opnd sn)
 8869        (move-opnd68-to-loc68 (opnd68->true-opnd68 opnd sn) areg)
 8870        areg)))
 8871(define (clo->opnd68 opnd keep sn)
 8872  (let ((base (clo-base opnd)) (offs (closed-var-offset (clo-index opnd))))
 8873    (if (lbl? base) (make-pcr (lbl-num base) offs) (clo->loc68 opnd keep sn))))
 8874(define (clo->loc68 opnd keep sn)
 8875  (let ((base (clo-base opnd)) (offs (closed-var-offset (clo-index opnd))))
 8876    (cond ((eq? base return-reg) (make-disp* (reg->reg68 base) offs))
 8877          ((obj? base)
 8878           (let ((areg (pick-atemp keep)))
 8879             (move-obj-to-loc68 (obj-val base) areg)
 8880             (make-disp* areg offs)))
 8881          (else
 8882           (let ((areg (pick-atemp keep)))
 8883             (move-opnd-to-loc68 base areg sn)
 8884             (make-disp* areg offs))))))
 8885(define (reg->reg68 reg) (reg-num->reg68 (reg-num reg)))
 8886(define (reg-num->reg68 num)
 8887  (if (= num 0) (make-areg gvm-reg0) (make-dreg (+ (- num 1) gvm-reg1))))
 8888(define (opnd->opnd68 opnd keep sn)
 8889  (cond ((lbl? opnd)
 8890         (let ((areg (pick-atemp keep)))
 8891           (emit-lea (make-pcr (lbl-num opnd) 0) areg)
 8892           areg))
 8893        ((obj? opnd)
 8894         (let ((val (obj-val opnd)))
 8895           (if (proc-obj? val)
 8896               (let ((num (add-object val)) (areg (pick-atemp keep)))
 8897                 (if num (emit-move-proc num areg) (emit-move-prim val areg))
 8898                 areg)
 8899               (let ((n (obj-encoding val)))
 8900                 (if n (make-imm n) (emit-const val))))))
 8901        ((clo? opnd) (clo->opnd68 opnd keep sn))
 8902        (else (loc->loc68 opnd keep sn))))
 8903(define (loc->loc68 loc keep sn)
 8904  (cond ((reg? loc) (reg->reg68 loc))
 8905        ((stk? loc) (make-frame-base-rel (stk-num loc)))
 8906        ((glo? loc) (make-glob (glo-name loc)))
 8907        ((clo? loc) (clo->loc68 loc keep sn))
 8908        (else (compiler-internal-error "loc->loc68, unknown 'loc':" loc))))
 8909(define (move-opnd68-to-loc opnd loc sn)
 8910  (cond ((reg? loc)
 8911         (make-top-of-frame-if-stk-opnd68 opnd sn)
 8912         (move-opnd68-to-loc68 (opnd68->true-opnd68 opnd sn) (reg->reg68 loc)))
 8913        ((stk? loc)
 8914         (let* ((loc-slot (stk-num loc))
 8915                (sn-after-opnd1 (if (< loc-slot sn) sn (- loc-slot 1))))
 8916           (if (> current-fs loc-slot)
 8917               (make-top-of-frame
 8918                (if (frame-base-rel? opnd)
 8919                    (let ((opnd-slot (frame-base-rel-slot opnd)))
 8920                      (if (>= opnd-slot (- loc-slot 1)) opnd-slot loc-slot))
 8921                    loc-slot)
 8922                sn-after-opnd1))
 8923           (let* ((opnd1 (opnd68->true-opnd68 opnd sn-after-opnd1))
 8924                  (opnd2 (opnd68->true-opnd68
 8925                          (make-frame-base-rel loc-slot)
 8926                          sn)))
 8927             (move-opnd68-to-loc68 opnd1 opnd2))))
 8928        ((glo? loc)
 8929         (make-top-of-frame-if-stk-opnd68 opnd sn)
 8930         (move-opnd68-to-loc68
 8931          (opnd68->true-opnd68 opnd sn)
 8932          (make-glob (glo-name loc))))
 8933        ((clo? loc)
 8934         (let ((clo (clo->loc68
 8935                     loc
 8936                     (temp-in-opnd68 opnd)
 8937                     (sn-opnd68 opnd sn))))
 8938           (make-top-of-frame-if-stk-opnd68 opnd sn)
 8939           (move-opnd68-to-loc68 (opnd68->true-opnd68 opnd sn) clo)))
 8940        (else
 8941         (compiler-internal-error "move-opnd68-to-loc, unknown 'loc':" loc))))
 8942(define (move-opnd-to-loc68 opnd loc68 sn)
 8943  (if (and (lbl? opnd) (areg? loc68))
 8944      (emit-lea (make-pcr (lbl-num opnd) 0) loc68)
 8945      (let* ((sn-after-opnd68 (sn-opnd68 loc68 sn))
 8946             (opnd68 (opnd->opnd68
 8947                      opnd
 8948                      (temp-in-opnd68 loc68)
 8949                      sn-after-opnd68)))
 8950        (make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn)
 8951        (let* ((opnd68* (opnd68->true-opnd68 opnd68 sn-after-opnd68))
 8952               (loc68* (opnd68->true-opnd68 loc68 sn)))
 8953          (move-opnd68-to-loc68 opnd68* loc68*)))))
 8954(define (copy-opnd-to-loc opnd loc sn)
 8955  (if (and (lbl? opnd) (eq? loc return-reg))
 8956      (emit-lea (make-pcr (lbl-num opnd) 0) (reg->reg68 loc))
 8957      (move-opnd68-to-loc (opnd->opnd68 opnd #f (sn-opnd loc sn)) loc sn)))
 8958(define (touch-reg68-to-reg68 src dst)
 8959  (define (trap-to-touch-handler dreg lbl)
 8960    (if ofile-stats?
 8961        (emit-stat
 8962         '((touch 0
 8963                  (determined-placeholder -1)
 8964                  (undetermined-placeholder 1)))))
 8965    (gen-trap
 8966     instr-source
 8967     entry-frame
 8968     #t
 8969     dreg
 8970     (+ touch-trap (dreg-num dreg))
 8971     lbl))
 8972  (define (touch-dreg-to-reg src dst)
 8973    (let ((lbl1 (new-lbl!)))
 8974      (emit-btst src placeholder-reg)
 8975      (emit-bne lbl1)
 8976      (if ofile-stats?
 8977          (emit-stat
 8978           '((touch 0 (non-placeholder -1) (determined-placeholder 1)))))
 8979      (trap-to-touch-handler src lbl1)
 8980      (move-opnd68-to-loc68 src dst)))
 8981  (define (touch-areg-to-dreg src dst)
 8982    (let ((lbl1 (new-lbl!)))
 8983      (emit-move.l src dst)
 8984      (emit-btst dst placeholder-reg)
 8985      (emit-bne lbl1)
 8986      (if ofile-stats?
 8987          (emit-stat
 8988           '((touch 0 (non-placeholder -1) (determined-placeholder 1)))))
 8989      (trap-to-touch-handler dst lbl1)))
 8990  (if ofile-stats? (emit-stat '((touch 1 (non-placeholder 1)))))
 8991  (cond ((dreg? src) (touch-dreg-to-reg src dst))
 8992        ((dreg? dst) (touch-areg-to-dreg src dst))
 8993        (else (emit-move.l src dtemp1) (touch-dreg-to-reg dtemp1 dst))))
 8994(define (touch-opnd-to-any-reg68 opnd sn)
 8995  (if (reg? opnd)
 8996      (let ((reg (reg->reg68 opnd))) (touch-reg68-to-reg68 reg reg) reg)
 8997      (let ((opnd68 (opnd->opnd68 opnd #f sn)))
 8998        (make-top-of-frame-if-stk-opnd68 opnd68 sn)
 8999        (move-opnd68-to-loc68 (opnd68->true-opnd68 opnd68 sn) dtemp1)
 9000        (touch-reg68-to-reg68 dtemp1 dtemp1)
 9001        dtemp1)))
 9002(define (touch-opnd-to-loc opnd loc sn)
 9003  (if (reg? opnd)
 9004      (let ((reg68 (reg->reg68 opnd)))
 9005        (if (reg? loc)
 9006            (touch-reg68-to-reg68 reg68 (reg->reg68 loc))
 9007            (begin
 9008              (touch-reg68-to-reg68 reg68 reg68)
 9009              (move-opnd68-to-loc reg68 loc sn))))
 9010      (if (reg? loc)
 9011          (let ((reg68 (reg->reg68 loc)))
 9012            (move-opnd-to-loc68 opnd reg68 sn)
 9013            (touch-reg68-to-reg68 reg68 reg68))
 9014          (let ((reg68 (touch-opnd-to-any-reg68 opnd sn)))
 9015            (move-opnd68-to-loc reg68 loc sn)))))
 9016(define (gen-trap source frame save-live? not-save-reg num lbl)
 9017  (define (adjust-slots l n)
 9018    (cond ((= n 0) (append l '()))
 9019          ((< n 0) (adjust-slots (cdr l) (+ n 1)))
 9020          (else (adjust-slots (cons empty-var l) (- n 1)))))
 9021  (define (set-slot! slots i x)
 9022    (let loop ((l slots) (n (- (length slots) i)))
 9023      (if (> n 0) (loop (cdr l) (- n 1)) (set-car! l x))))
 9024  (let ((ret-slot (frame-first-empty-slot frame)))
 9025    (let loop1 ((save1 '()) (save2 #f) (regs (frame-regs frame)) (i 0))
 9026      (if (pair? regs)
 9027          (let ((var (car regs)))
 9028            (if (eq? var ret-var)
 9029                (let ((x (cons (reg->reg68 (make-reg i)) var)))
 9030                  (if (> ret-slot current-fs)
 9031                      (loop1 (cons x save1) save2 (cdr regs) (+ i 1))
 9032                      (loop1 save1 x (cdr regs) (+ i 1))))
 9033                (if (and save-live?
 9034                         (frame-live? var frame)
 9035                         (not (eqv? not-save-reg (reg->reg68 (make-reg i)))))
 9036                    (loop1 (cons (cons (reg->reg68 (make-reg i)) var) save1)
 9037                           save2
 9038                           (cdr regs)
 9039                           (+ i 1))
 9040                    (loop1 save1 save2 (cdr regs) (+ i 1)))))
 9041          (let ((order (sort-list save1 (lambda (x y) (< (car x) (car y))))))
 9042            (let ((slots (append (map cdr order)
 9043                                 (adjust-slots
 9044                                  (frame-slots frame)
 9045                                  (- current-fs (frame-size frame)))))
 9046                  (reg-list (map car order))
 9047                  (nb-regs (length order)))
 9048              (define (trap)
 9049                (emit-trap2 num '())
 9050                (gen-label-return*
 9051                 (new-lbl!)
 9052                 (add-first-class-label! source slots frame)
 9053                 slots
 9054                 0))
 9055              (if save2
 9056                  (begin
 9057                    (emit-move.l
 9058                     (car save2)
 9059                     (make-disp*
 9060                      sp-reg
 9061                      (* pointer-size (- current-fs ret-slot))))
 9062                    (set-slot! slots ret-slot (cdr save2))))
 9063              (if (> (length order) 2)
 9064                  (begin
 9065                    (emit-movem.l reg-list pdec-sp)
 9066                    (trap)
 9067                    (emit-movem.l pinc-sp reg-list))
 9068                  (let loop2 ((l (reverse reg-list)))
 9069                    (if (pair? l)
 9070                        (let ((reg (car l)))
 9071                          (emit-move.l reg pdec-sp)
 9072                          (loop2 (cdr l))
 9073                          (emit-move.l pinc-sp reg))
 9074                        (trap))))
 9075              (if save2
 9076                  (emit-move.l
 9077                   (make-disp* sp-reg (* pointer-size (- current-fs ret-slot)))
 9078                   (car save2)))
 9079              (emit-label lbl)))))))
 9080(define (gen-label-simple lbl sn)
 9081  (if ofile-stats?
 9082      (begin (stat-clear!) (stat-add! '(gvm-instr label simple) 1)))
 9083  (set! pointers-allocated 0)
 9084  (emit-label lbl))
 9085(define (gen-label-entry lbl nb-parms min rest? closed? sn)
 9086  (if ofile-stats?
 9087      (begin
 9088        (stat-clear!)
 9089        (stat-add!
 9090         (list 'gvm-instr
 9091               'label
 9092               'entry
 9093               nb-parms
 9094               min
 9095               (if rest? 'rest 'not-rest)
 9096               (if closed? 'closed 'not-closed))
 9097         1)))
 9098  (set! pointers-allocated 0)
 9099  (let ((label-descr (add-first-class-label! instr-source '() exit-frame)))
 9100    (if (= lbl entry-lbl-num)
 9101        (emit-label lbl)
 9102        (emit-label-subproc lbl entry-lbl-num label-descr)))
 9103  (let* ((nb-parms* (if rest? (- nb-parms 1) nb-parms))
 9104         (dispatch-lbls (make-vector (+ (- nb-parms min) 1)))
 9105         (optional-lbls (make-vector (+ (- nb-parms min) 1))))
 9106    (let loop ((i min))
 9107      (if (<= i nb-parms)
 9108          (let ((lbl (new-lbl!)))
 9109            (vector-set! optional-lbls (- nb-parms i) lbl)
 9110            (vector-set!
 9111             dispatch-lbls
 9112             (- nb-parms i)
 9113             (if (or (>= i nb-parms) (<= nb-parms nb-arg-regs))
 9114                 lbl
 9115                 (new-lbl!)))
 9116            (loop (+ i 1)))))
 9117    (if closed?
 9118        (let ((closure-reg (reg-num->reg68 (+ nb-arg-regs 1))))
 9119          (emit-move.l pinc-sp closure-reg)
 9120          (emit-subq.l 6 closure-reg)
 9121          (if (or (and (<= min 1) (<= 1 nb-parms*))
 9122                  (and (<= min 2) (<= 2 nb-parms*)))
 9123              (emit-move.w dtemp1 dtemp1))))
 9124    (if (and (<= min 2) (<= 2 nb-parms*))
 9125        (emit-beq (vector-ref dispatch-lbls (- nb-parms 2))))
 9126    (if (and (<= min 1) (<= 1 nb-parms*))
 9127        (emit-bmi (vector-ref dispatch-lbls (- nb-parms 1))))
 9128    (let loop ((i min))
 9129      (if (<= i nb-parms*)
 9130          (begin
 9131            (if (not (or (= i 1) (= i 2)))
 9132                (begin
 9133                  (emit-cmp.w (make-imm (encode-arg-count i)) arg-count-reg)
 9134                  (emit-beq (vector-ref dispatch-lbls (- nb-parms i)))))
 9135            (loop (+ i 1)))))
 9136    (cond (rest?
 9137           (emit-trap1
 9138            (if closed? rest-params-closed-trap rest-params-trap)
 9139            (list min nb-parms*))
 9140           (if (not closed?) (emit-lbl-ptr lbl))
 9141           (set! pointers-allocated 1)
 9142           (gen-guarantee-fudge)
 9143           (emit-bra (vector-ref optional-lbls 0)))
 9144          ((= min nb-parms*)
 9145           (emit-trap1
 9146            (if closed? wrong-nb-arg1-closed-trap wrong-nb-arg1-trap)
 9147            (list nb-parms*))
 9148           (if (not closed?) (emit-lbl-ptr lbl)))
 9149          (else
 9150           (emit-trap1
 9151            (if closed? wrong-nb-arg2-closed-trap wrong-nb-arg2-trap)
 9152            (list min nb-parms*))
 9153           (if (not closed?) (emit-lbl-ptr lbl))))
 9154    (if (> nb-parms nb-arg-regs)
 9155        (let loop1 ((i (- nb-parms 1)))
 9156          (if (>= i min)
 9157              (let ((nb-stacked (if (<= i nb-arg-regs) 0 (- i nb-arg-regs))))
 9158                (emit-label (vector-ref dispatch-lbls (- nb-parms i)))
 9159                (let loop2 ((j 1))
 9160                  (if (and (<= j nb-arg-regs)
 9161                           (<= j i)
 9162                           (<= j (- (- nb-parms nb-arg-regs) nb-stacked)))
 9163                      (begin
 9164                        (emit-move.l (reg-num->reg68 j) pdec-sp)
 9165                        (loop2 (+ j 1)))
 9166                      (let loop3 ((k j))
 9167                        (if (and (<= k nb-arg-regs) (<= k i))
 9168                            (begin
 9169                              (emit-move.l
 9170                               (reg-num->reg68 k)
 9171                               (reg-num->reg68 (+ (- k j) 1)))
 9172                              (loop3 (+ k 1)))))))
 9173                (if (> i min)
 9174                    (emit-bra (vector-ref optional-lbls (- nb-parms i))))
 9175                (loop1 (- i 1))))))
 9176    (let loop ((i min))
 9177      (if (<= i nb-parms)
 9178          (let ((val (if (= i nb-parms*) bits-null bits-unass)))
 9179            (emit-label (vector-ref optional-lbls (- nb-parms i)))
 9180            (cond ((> (- nb-parms i) nb-arg-regs)
 9181                   (move-n-to-loc68 val pdec-sp))
 9182                  ((< i nb-parms)
 9183                   (move-n-to-loc68
 9184                    val
 9185                    (reg-num->reg68 (parm->reg-num (+ i 1) nb-parms)))))
 9186            (loop (+ i 1)))))))
 9187(define (encode-arg-count n) (cond ((= n 1) -1) ((= n 2) 0) (else (+ n 1))))
 9188(define (parm->reg-num i nb-parms)
 9189  (if (<= nb-parms nb-arg-regs) i (+ i (- nb-arg-regs nb-parms))))
 9190(define (no-arg-check-entry-offset proc nb-args)
 9191  (let ((x (proc-obj-call-pat proc)))
 9192    (if (and (pair? x) (null? (cdr x)))
 9193        (let ((arg-count (car x)))
 9194          (if (= arg-count nb-args)
 9195              (if (or (= arg-count 1) (= arg-count 2)) 10 14)
 9196              0))
 9197        0)))
 9198(define (gen-label-return lbl sn)
 9199  (if ofile-stats?
 9200      (begin (stat-clear!) (stat-add! '(gvm-instr label return) 1)))
 9201  (set! pointers-allocated 0)
 9202  (let ((slots (frame-slots exit-frame)))
 9203    (gen-label-return*
 9204     lbl
 9205     (add-first-class-label! instr-source slots exit-frame)
 9206     slots
 9207     0)))
 9208(define (gen-label-return* lbl label-descr slots extra)
 9209  (let ((i (pos-in-list ret-var slots)))
 9210    (if i
 9211        (let* ((fs (length slots)) (link (- fs i)))
 9212          (emit-label-return lbl entry-lbl-num (+ fs extra) link label-descr))
 9213        (compiler-internal-error
 9214         "gen-label-return*, no return address in frame"))))
 9215(define (gen-label-task-entry lbl sn)
 9216  (if ofile-stats?
 9217      (begin (stat-clear!) (stat-add! '(gvm-instr label task-entry) 1)))
 9218  (set! pointers-allocated 0)
 9219  (emit-label lbl)
 9220  (if (= current-fs 0)
 9221      (begin
 9222        (emit-move.l (reg->reg68 return-reg) pdec-sp)
 9223        (emit-move.l sp-reg (make-pinc ltq-tail-reg)))
 9224      (begin
 9225        (emit-move.l sp-reg atemp1)
 9226        (emit-move.l (make-pinc atemp1) pdec-sp)
 9227        (let loop ((i (- current-fs 1)))
 9228          (if (> i 0)
 9229              (begin
 9230                (emit-move.l (make-pinc atemp1) (make-disp atemp1 -8))
 9231                (loop (- i 1)))))
 9232        (emit-move.l (reg->reg68 return-reg) (make-pdec atemp1))
 9233        (emit-move.l atemp1 (make-pinc ltq-tail-reg))))
 9234  (emit-move.l ltq-tail-reg ltq-tail-slot))
 9235(define (gen-label-task-return lbl sn)
 9236  (if ofile-stats?
 9237      (begin (stat-clear!) (stat-add! '(gvm-instr label task-return) 1)))
 9238  (set! pointers-allocated 0)
 9239  (let ((slots (frame-slots exit-frame)))
 9240    (set! current-fs (+ current-fs 1))
 9241    (let ((dummy-lbl (new-lbl!)) (skip-lbl (new-lbl!)))
 9242      (gen-label-return*
 9243       dummy-lbl
 9244       (add-first-class-label! instr-source slots exit-frame)
 9245       slots
 9246       1)
 9247      (emit-bra skip-lbl)
 9248      (gen-label-task-return*
 9249       lbl
 9250       (add-first-class-label! instr-source slots exit-frame)
 9251       slots
 9252       1)
 9253      (emit-subq.l pointer-size ltq-tail-reg)
 9254      (emit-label skip-lbl))))
 9255(define (gen-label-task-return* lbl label-descr slots extra)
 9256  (let ((i (pos-in-list ret-var slots)))
 9257    (if i
 9258        (let* ((fs (length slots)) (link (- fs i)))
 9259          (emit-label-task-return
 9260           lbl
 9261           entry-lbl-num
 9262           (+ fs extra)
 9263           link
 9264           label-descr))
 9265        (compiler-internal-error
 9266         "gen-label-task-return*, no return address in frame"))))
 9267(define (gen-apply prim opnds loc sn)
 9268  (if ofile-stats?
 9269      (begin
 9270        (stat-add!
 9271         (list 'gvm-instr
 9272               'apply
 9273               (string->canonical-symbol (proc-obj-name prim))
 9274               (map opnd-stat opnds)
 9275               (if loc (opnd-stat loc) #f))
 9276         1)
 9277        (for-each fetch-stat-add! opnds)
 9278        (if loc (store-stat-add! loc))))
 9279  (let ((x (proc-obj-inlinable prim)))
 9280    (if (not x)
 9281        (compiler-internal-error "gen-APPLY, unknown 'prim':" prim)
 9282        (if (or (needed? loc sn) (car x)) ((cdr x) opnds loc sn)))))
 9283(define (define-apply name side-effects? proc)
 9284  (let ((prim (get-prim-info name)))
 9285    (proc-obj-inlinable-set! prim (cons side-effects? proc))))
 9286(define (gen-copy opnd loc sn)
 9287  (if ofile-stats?
 9288      (begin
 9289        (stat-add! (list 'gvm-instr 'copy (opnd-stat opnd) (opnd-stat loc)) 1)
 9290        (fetch-stat-add! opnd)
 9291        (store-stat-add! loc)))
 9292  (if (needed? loc sn) (copy-opnd-to-loc opnd loc sn)))
 9293(define (gen-close parms sn)
 9294  (define (size->bytes size)
 9295    (* (quotient
 9296        (+ (* (+ size 2) pointer-size) (- cache-line-length 1))
 9297        cache-line-length)
 9298       cache-line-length))
 9299  (define (parms->bytes parms)
 9300    (if (null? parms)
 9301        0
 9302        (+ (size->bytes (length (closure-parms-opnds (car parms))))
 9303           (parms->bytes (cdr parms)))))
 9304  (if ofile-stats?
 9305      (begin
 9306        (for-each
 9307         (lambda (x)
 9308           (stat-add!
 9309            (list 'gvm-instr
 9310                  'close
 9311                  (opnd-stat (closure-parms-loc x))
 9312                  (map opnd-stat (closure-parms-opnds x)))
 9313            1)
 9314           (store-stat-add! (closure-parms-loc x))
 9315           (fetch-stat-add! (make-lbl (closure-parms-lbl x)))
 9316           (for-each fetch-stat-add! (closure-parms-opnds x)))
 9317         parms)))
 9318  (let ((total-space-needed (parms->bytes parms)) (lbl1 (new-lbl!)))
 9319    (emit-move.l closure-ptr-slot atemp2)
 9320    (move-n-to-loc68 total-space-needed dtemp1)
 9321    (emit-sub.l dtemp1 atemp2)
 9322    (emit-cmp.l closure-lim-slot atemp2)
 9323    (emit-bcc lbl1)
 9324    (gen-trap instr-source entry-frame #f #f closure-alloc-trap lbl1)
 9325    (emit-move.l atemp2 closure-ptr-slot)
 9326    (let* ((opnds* (apply append (map closure-parms-opnds parms)))
 9327           (sn* (sn-opnds opnds* sn)))
 9328      (let loop1 ((parms parms))
 9329        (let ((loc (closure-parms-loc (car parms)))
 9330              (size (length (closure-parms-opnds (car parms))))
 9331              (rest (cdr parms)))
 9332          (if (= size 1)
 9333              (emit-addq.l type-procedure atemp2)
 9334              (emit-move.w
 9335               (make-imm (+ 32768 (* (+ size 1) 4)))
 9336               (make-pinc atemp2)))
 9337          (move-opnd68-to-loc
 9338           atemp2
 9339           loc
 9340           (sn-opnds (map closure-parms-loc rest) sn*))
 9341          (if (null? rest)
 9342              (add-n-to-loc68
 9343               (+ (- (size->bytes size) total-space-needed) 2)
 9344               atemp2)
 9345              (begin
 9346                (add-n-to-loc68 (- (size->bytes size) type-procedure) atemp2)
 9347                (loop1 rest)))))
 9348      (let loop2 ((parms parms))
 9349        (let* ((opnds (closure-parms-opnds (car parms)))
 9350               (lbl (closure-parms-lbl (car parms)))
 9351               (size (length opnds))
 9352               (rest (cdr parms)))
 9353          (emit-lea (make-pcr lbl 0) atemp1)
 9354          (emit-move.l atemp1 (make-pinc atemp2))
 9355          (let loop3 ((opnds opnds))
 9356            (if (not (null? opnds))
 9357                (let ((sn** (sn-opnds
 9358                             (apply append (map closure-parms-opnds rest))
 9359                             sn)))
 9360                  (move-opnd-to-loc68
 9361                   (car opnds)
 9362                   (make-pinc atemp2)
 9363                   (sn-opnds (cdr opnds) sn**))
 9364                  (loop3 (cdr opnds)))))
 9365          (if (not (null? rest))
 9366              (begin
 9367                (add-n-to-loc68
 9368                 (- (size->bytes size) (* (+ size 1) pointer-size))
 9369                 atemp2)
 9370                (loop2 rest))))))))
 9371(define (gen-ifjump test opnds true-lbl false-lbl poll? next-lbl)
 9372  (if ofile-stats?
 9373      (begin
 9374        (stat-add!
 9375         (list 'gvm-instr
 9376               'ifjump
 9377               (string->canonical-symbol (proc-obj-name test))
 9378               (map opnd-stat opnds)
 9379               (if poll? 'poll 'not-poll))
 9380         1)
 9381        (for-each fetch-stat-add! opnds)
 9382        (stat-dump!)))
 9383  (let ((proc (proc-obj-test test)))
 9384    (if proc
 9385        (gen-ifjump* proc opnds true-lbl false-lbl poll? next-lbl)
 9386        (compiler-internal-error "gen-IFJUMP, unknown 'test':" test))))
 9387(define (gen-ifjump* proc opnds true-lbl false-lbl poll? next-lbl)
 9388  (let ((fs (frame-size exit-frame)))
 9389    (define (double-branch)
 9390      (proc #t opnds false-lbl fs)
 9391      (if ofile-stats?
 9392          (emit-stat
 9393           '((gvm-instr.ifjump.fall-through 1)
 9394             (gvm-instr.ifjump.double-branch 1))))
 9395      (emit-bra true-lbl)
 9396      (gen-deferred-code!))
 9397    (gen-guarantee-fudge)
 9398    (if poll? (gen-poll))
 9399    (if next-lbl
 9400        (cond ((= true-lbl next-lbl)
 9401               (proc #t opnds false-lbl fs)
 9402               (if ofile-stats?
 9403                   (emit-stat '((gvm-instr.ifjump.fall-through 1)))))
 9404              ((= false-lbl next-lbl)
 9405               (proc #f opnds true-lbl fs)
 9406               (if ofile-stats?
 9407                   (emit-stat '((gvm-instr.ifjump.fall-through 1)))))
 9408              (else (double-branch)))
 9409        (double-branch))))
 9410(define (define-ifjump name proc)
 9411  (define-apply
 9412   name
 9413   #f
 9414   (lambda (opnds loc sn)
 9415     (let ((true-lbl (new-lbl!))
 9416           (cont-lbl (new-lbl!))
 9417           (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
 9418                      (reg->reg68 loc)
 9419                      dtemp1)))
 9420       (proc #f opnds true-lbl current-fs)
 9421       (move-n-to-loc68 bits-false reg68)
 9422       (emit-bra cont-lbl)
 9423       (emit-label true-lbl)
 9424       (move-n-to-loc68 bits-true reg68)
 9425       (emit-label cont-lbl)
 9426       (move-opnd68-to-loc reg68 loc sn))))
 9427  (proc-obj-test-set! (get-prim-info name) proc))
 9428(define (gen-jump opnd nb-args poll? next-lbl)
 9429  (let ((fs (frame-size exit-frame)))
 9430    (if ofile-stats?
 9431        (begin
 9432          (stat-add!
 9433           (list 'gvm-instr
 9434                 'jump
 9435                 (opnd-stat opnd)
 9436                 nb-args
 9437                 (if poll? 'poll 'not-poll))
 9438           1)
 9439          (jump-stat-add! opnd)
 9440          (if (and (lbl? opnd) next-lbl (= next-lbl (lbl-num opnd)))
 9441              (stat-add! '(gvm-instr.jump.fall-through) 1))
 9442          (stat-dump!)))
 9443    (gen-guarantee-fudge)
 9444    (cond ((glo? opnd)
 9445           (if poll? (gen-poll))
 9446           (setup-jump fs nb-args)
 9447           (emit-jmp-glob (make-glob (glo-name opnd)))
 9448           (gen-deferred-code!))
 9449          ((and (stk? opnd) (= (stk-num opnd) (+ fs 1)) (not nb-args))
 9450           (if poll? (gen-poll))
 9451           (setup-jump (+ fs 1) nb-args)
 9452           (emit-rts)
 9453           (gen-deferred-code!))
 9454          ((lbl? opnd)
 9455           (if (and poll?
 9456                    (= fs current-fs)
 9457                    (not nb-args)
 9458                    (not (and next-lbl (= next-lbl (lbl-num opnd)))))
 9459               (gen-poll-branch (lbl-num opnd))
 9460               (begin
 9461                 (if poll? (gen-poll))
 9462                 (setup-jump fs nb-args)
 9463                 (if (not (and next-lbl (= next-lbl (lbl-num opnd))))
 9464                     (emit-bra (lbl-num opnd))))))
 9465          ((obj? opnd)
 9466           (if poll? (gen-poll))
 9467           (let ((val (obj-val opnd)))
 9468             (if (proc-obj? val)
 9469                 (let ((num (add-object val))
 9470                       (offset (no-arg-check-entry-offset val nb-args)))
 9471                   (setup-jump fs (if (<= offset 0) nb-args #f))
 9472                   (if num
 9473                       (emit-jmp-proc num offset)
 9474                       (emit-jmp-prim val offset))
 9475                   (gen-deferred-code!))
 9476                 (gen-jump* (opnd->opnd68 opnd #f fs) fs nb-args))))
 9477          (else
 9478           (if poll? (gen-poll))
 9479           (gen-jump* (opnd->opnd68 opnd #f fs) fs nb-args)))))
 9480(define (gen-jump* opnd fs nb-args)
 9481  (if nb-args
 9482      (let ((lbl (new-lbl!)))
 9483        (make-top-of-frame-if-stk-opnd68 opnd fs)
 9484        (move-opnd68-to-loc68 (opnd68->true-opnd68 opnd fs) atemp1)
 9485        (shrink-frame fs)
 9486        (emit-move.l atemp1 dtemp1)
 9487        (emit-addq.w (modulo (- type-pair type-procedure) 8) dtemp1)
 9488        (emit-btst dtemp1 pair-reg)
 9489        (emit-beq lbl)
 9490        (move-n-to-loc68 (encode-arg-count nb-args) arg-count-reg)
 9491        (emit-trap3 non-proc-jump-trap)
 9492        (emit-label lbl)
 9493        (move-n-to-loc68 (encode-arg-count nb-args) arg-count-reg)
 9494        (emit-jmp (make-ind atemp1)))
 9495      (let ((areg (move-opnd68-to-any-areg opnd #f fs)))
 9496        (setup-jump fs nb-args)
 9497        (emit-jmp (make-ind areg))))
 9498  (gen-deferred-code!))
 9499(define (setup-jump fs nb-args)
 9500  (shrink-frame fs)
 9501  (if nb-args (move-n-to-loc68 (encode-arg-count nb-args) arg-count-reg)))
 9502(define (gen-poll)
 9503  (let ((lbl (new-lbl!)))
 9504    (emit-dbra poll-timer-reg lbl)
 9505    (emit-moveq (- polling-intermittency 1) poll-timer-reg)
 9506    (emit-cmp.l intr-flag-slot sp-reg)
 9507    (emit-bcc lbl)
 9508    (gen-trap instr-source entry-frame #f #f intr-trap lbl)))
 9509(define (gen-poll-branch lbl)
 9510  (emit-dbra poll-timer-reg lbl)
 9511  (emit-moveq (- polling-intermittency 1) poll-timer-reg)
 9512  (emit-cmp.l intr-flag-slot sp-reg)
 9513  (emit-bcc lbl)
 9514  (gen-trap instr-source entry-frame #f #f intr-trap (new-lbl!))
 9515  (emit-bra lbl))
 9516(define (make-gen-slot-ref slot type)
 9517  (lambda (opnds loc sn)
 9518    (let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
 9519      (move-opnd-to-loc68 opnd atemp1 sn-loc)
 9520      (move-opnd68-to-loc
 9521       (make-disp* atemp1 (- (* slot pointer-size) type))
 9522       loc
 9523       sn))))
 9524(define (make-gen-slot-set! slot type)
 9525  (lambda (opnds loc sn)
 9526    (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
 9527      (let* ((first-opnd (car opnds))
 9528             (second-opnd (cadr opnds))
 9529             (sn-second-opnd (sn-opnd second-opnd sn-loc)))
 9530        (move-opnd-to-loc68 first-opnd atemp1 sn-second-opnd)
 9531        (move-opnd-to-loc68
 9532         second-opnd
 9533         (make-disp* atemp1 (- (* slot pointer-size) type))
 9534         sn-loc)
 9535        (if loc
 9536            (if (not (eq? first-opnd loc))
 9537                (move-opnd68-to-loc atemp1 loc sn)))))))
 9538(define (gen-cons opnds loc sn)
 9539  (let ((sn-loc (sn-opnd loc sn)))
 9540    (let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
 9541      (gen-guarantee-space 2)
 9542      (if (contains-opnd? loc second-opnd)
 9543          (let ((sn-second-opnd (sn-opnd second-opnd sn-loc)))
 9544            (move-opnd-to-loc68 first-opnd (make-pdec heap-reg) sn-second-opnd)
 9545            (move-opnd68-to-loc68 heap-reg atemp2)
 9546            (move-opnd-to-loc68 second-opnd (make-pdec heap-reg) sn-loc)
 9547            (move-opnd68-to-loc atemp2 loc sn))
 9548          (let* ((sn-second-opnd (sn-opnd second-opnd sn))
 9549                 (sn-loc (sn-opnd loc sn-second-opnd)))
 9550            (move-opnd-to-loc68 first-opnd (make-pdec heap-reg) sn-loc)
 9551            (move-opnd68-to-loc heap-reg loc sn-second-opnd)
 9552            (move-opnd-to-loc68 second-opnd (make-pdec heap-reg) sn))))))
 9553(define (make-gen-apply-c...r pattern)
 9554  (lambda (opnds loc sn)
 9555    (let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
 9556      (move-opnd-to-loc68 opnd atemp1 sn-loc)
 9557      (let loop ((pattern pattern))
 9558        (if (<= pattern 3)
 9559            (if (= pattern 3)
 9560                (move-opnd68-to-loc (make-pdec atemp1) loc sn)
 9561                (move-opnd68-to-loc (make-ind atemp1) loc sn))
 9562            (begin
 9563              (if (odd? pattern)
 9564                  (emit-move.l (make-pdec atemp1) atemp1)
 9565                  (emit-move.l (make-ind atemp1) atemp1))
 9566              (loop (quotient pattern 2))))))))
 9567(define (gen-set-car! opnds loc sn)
 9568  (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
 9569    (let* ((first-opnd (car opnds))
 9570           (second-opnd (cadr opnds))
 9571           (sn-second-opnd (sn-opnd second-opnd sn-loc)))
 9572      (move-opnd-to-loc68 first-opnd atemp1 sn-second-opnd)
 9573      (move-opnd-to-loc68 second-opnd (make-ind atemp1) sn-loc)
 9574      (if (and loc (not (eq? first-opnd loc)))
 9575          (move-opnd68-to-loc atemp1 loc sn)))))
 9576(define (gen-set-cdr! opnds loc sn)
 9577  (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
 9578    (let* ((first-opnd (car opnds))
 9579           (second-opnd (cadr opnds))
 9580           (sn-second-opnd (sn-opnd second-opnd sn-loc)))
 9581      (move-opnd-to-loc68 first-opnd atemp1 sn-second-opnd)
 9582      (if (and loc (not (eq? first-opnd loc)))
 9583          (move-opnd-to-loc68
 9584           second-opnd
 9585           (make-disp atemp1 (- pointer-size))
 9586           sn-loc)
 9587          (move-opnd-to-loc68 second-opnd (make-pdec atemp1) sn-loc))
 9588      (if (and loc (not (eq? first-opnd loc)))
 9589          (move-opnd68-to-loc atemp1 loc sn)))))
 9590(define (commut-oper gen opnds loc sn self? accum-self accum-other)
 9591  (if (null? opnds)
 9592      (gen (reverse accum-self) (reverse accum-other) loc sn self?)
 9593      (let ((opnd (car opnds)) (rest (cdr opnds)))
 9594        (cond ((and (not self?) (eq? opnd loc))
 9595               (commut-oper gen rest loc sn #t accum-self accum-other))
 9596              ((contains-opnd? loc opnd)
 9597               (commut-oper
 9598                gen
 9599                rest
 9600                loc
 9601                sn
 9602                self?
 9603                (cons opnd accum-self)
 9604                accum-other))
 9605              (else
 9606               (commut-oper
 9607                gen
 9608                rest
 9609                loc
 9610                sn
 9611                self?
 9612                accum-self
 9613                (cons opnd accum-other)))))))
 9614(define (gen-add-in-place opnds loc68 sn)
 9615  (if (not (null? opnds))
 9616      (let* ((first-opnd (car opnds))
 9617             (other-opnds (cdr opnds))
 9618             (sn-other-opnds (sn-opnds other-opnds sn))
 9619             (sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
 9620             (opnd68 (opnd->opnd68
 9621                      first-opnd
 9622                      (temp-in-opnd68 loc68)
 9623                      (sn-opnd68 loc68 sn))))
 9624        (make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn-other-opnds)
 9625        (if (imm? opnd68)
 9626            (add-n-to-loc68
 9627             (imm-val opnd68)
 9628             (opnd68->true-opnd68 loc68 sn-other-opnds))
 9629            (let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
 9630              (if (or (dreg? opnd68) (reg68? loc68))
 9631                  (emit-add.l
 9632                   opnd68*
 9633                   (opnd68->true-opnd68 loc68 sn-other-opnds))
 9634                  (begin
 9635                    (move-opnd68-to-loc68 opnd68* dtemp1)
 9636                    (emit-add.l
 9637                     dtemp1
 9638                     (opnd68->true-opnd68 loc68 sn-other-opnds))))))
 9639        (gen-add-in-place other-opnds loc68 sn))))
 9640(define (gen-add self-opnds other-opnds loc sn self?)
 9641  (let* ((opnds (append self-opnds other-opnds))
 9642         (first-opnd (car opnds))
 9643         (other-opnds (cdr opnds))
 9644         (sn-other-opnds (sn-opnds other-opnds sn))
 9645         (sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
 9646    (if (<= (length self-opnds) 1)
 9647        (let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
 9648          (if self?
 9649              (gen-add-in-place opnds loc68 sn)
 9650              (begin
 9651                (move-opnd-to-loc68 first-opnd loc68 sn-other-opnds)
 9652                (gen-add-in-place other-opnds loc68 sn))))
 9653        (begin
 9654          (move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn-other-opnds))
 9655          (gen-add-in-place other-opnds dtemp1 (sn-opnd loc sn))
 9656          (if self?
 9657              (let ((loc68 (loc->loc68 loc dtemp1 sn)))
 9658                (make-top-of-frame-if-stk-opnd68 loc68 sn)
 9659                (emit-add.l dtemp1 (opnd68->true-opnd68 loc68 sn)))
 9660              (move-opnd68-to-loc dtemp1 loc sn))))))
 9661(define (gen-sub-in-place opnds loc68 sn)
 9662  (if (not (null? opnds))
 9663      (let* ((first-opnd (car opnds))
 9664             (other-opnds (cdr opnds))
 9665             (sn-other-opnds (sn-opnds other-opnds sn))
 9666             (sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
 9667             (opnd68 (opnd->opnd68
 9668                      first-opnd
 9669                      (temp-in-opnd68 loc68)
 9670                      (sn-opnd68 loc68 sn))))
 9671        (make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn-other-opnds)
 9672        (if (imm? opnd68)
 9673            (add-n-to-loc68
 9674             (- (imm-val opnd68))
 9675             (opnd68->true-opnd68 loc68 sn-other-opnds))
 9676            (let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
 9677              (if (or (dreg? opnd68) (reg68? loc68))
 9678                  (emit-sub.l
 9679                   opnd68*
 9680                   (opnd68->true-opnd68 loc68 sn-other-opnds))
 9681                  (begin
 9682                    (move-opnd68-to-loc68 opnd68* dtemp1)
 9683                    (emit-sub.l
 9684                     dtemp1
 9685                     (opnd68->true-opnd68 loc68 sn-other-opnds))))))
 9686        (gen-sub-in-place other-opnds loc68 sn))))
 9687(define (gen-sub first-opnd other-opnds loc sn self-opnds?)
 9688  (if (null? other-opnds)
 9689      (if (and (or (reg? loc) (stk? loc)) (not (eq? loc return-reg)))
 9690          (begin
 9691            (copy-opnd-to-loc first-opnd loc (sn-opnd loc sn))
 9692            (let ((loc68 (loc->loc68 loc #f sn)))
 9693              (make-top-of-frame-if-stk-opnd68 loc68 sn)
 9694              (emit-neg.l (opnd68->true-opnd68 loc68 sn))))
 9695          (begin
 9696            (move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn))
 9697            (emit-neg.l dtemp1)
 9698            (move-opnd68-to-loc dtemp1 loc sn)))
 9699      (let* ((sn-other-opnds (sn-opnds other-opnds sn))
 9700             (sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
 9701        (if (and (not self-opnds?) (or (reg? loc) (stk? loc)))
 9702            (let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
 9703              (if (not (eq? first-opnd loc))
 9704                  (move-opnd-to-loc68 first-opnd loc68 sn-other-opnds))
 9705              (gen-sub-in-place other-opnds loc68 sn))
 9706            (begin
 9707              (move-opnd-to-loc68
 9708               first-opnd
 9709               dtemp1
 9710               (sn-opnd loc sn-other-opnds))
 9711              (gen-sub-in-place other-opnds dtemp1 (sn-opnd loc sn))
 9712              (move-opnd68-to-loc dtemp1 loc sn))))))
 9713(define (gen-mul-in-place opnds reg68 sn)
 9714  (if (not (null? opnds))
 9715      (let* ((first-opnd (car opnds))
 9716             (other-opnds (cdr opnds))
 9717             (sn-other-opnds (sn-opnds other-opnds sn))
 9718             (opnd68 (opnd->opnd68 first-opnd (temp-in-opnd68 reg68) sn)))
 9719        (make-top-of-frame-if-stk-opnd68 opnd68 sn-other-opnds)
 9720        (if (imm? opnd68)
 9721            (mul-n-to-reg68 (quotient (imm-val opnd68) 8) reg68)
 9722            (begin
 9723              (emit-asr.l (make-imm 3) reg68)
 9724              (emit-muls.l (opnd68->true-opnd68 opnd68 sn-other-opnds) reg68)))
 9725        (gen-mul-in-place other-opnds reg68 sn))))
 9726(define (gen-mul self-opnds other-opnds loc sn self?)
 9727  (let* ((opnds (append self-opnds other-opnds))
 9728         (first-opnd (car opnds))
 9729         (other-opnds (cdr opnds))
 9730         (sn-other-opnds (sn-opnds other-opnds sn))
 9731         (sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
 9732    (if (null? self-opnds)
 9733        (let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
 9734          (if self?
 9735              (gen-mul-in-place opnds loc68 sn)
 9736              (begin
 9737                (move-opnd-to-loc68 first-opnd loc68 sn-other-opnds)
 9738                (gen-mul-in-place other-opnds loc68 sn))))
 9739        (begin
 9740          (move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn-other-opnds))
 9741          (gen-mul-in-place other-opnds dtemp1 (sn-opnd loc sn))
 9742          (if self?
 9743              (let ((loc68 (loc->loc68 loc dtemp1 sn)))
 9744                (make-top-of-frame-if-stk-opnd68 loc68 sn)
 9745                (emit-asr.l (make-imm 3) dtemp1)
 9746                (emit-muls.l dtemp1 (opnd68->true-opnd68 loc68 sn)))
 9747              (move-opnd68-to-loc dtemp1 loc sn))))))
 9748(define (gen-div-in-place opnds reg68 sn)
 9749  (if (not (null? opnds))
 9750      (let* ((first-opnd (car opnds))
 9751             (other-opnds (cdr opnds))
 9752             (sn-other-opnds (sn-opnds other-opnds sn))
 9753             (sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
 9754             (opnd68 (opnd->opnd68 first-opnd (temp-in-opnd68 reg68) sn)))
 9755        (make-top-of-frame-if-stk-opnd68 opnd68 sn-other-opnds)
 9756        (if (imm? opnd68)
 9757            (let ((n (quotient (imm-val opnd68) 8)))
 9758              (div-n-to-reg68 n reg68)
 9759              (if (> (abs n) 1) (emit-and.w (make-imm -8) reg68)))
 9760            (let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
 9761              (emit-divsl.l opnd68* reg68 reg68)
 9762              (emit-asl.l (make-imm 3) reg68)))
 9763        (gen-div-in-place other-opnds reg68 sn))))
 9764(define (gen-div first-opnd other-opnds loc sn self-opnds?)
 9765  (if (null? other-opnds)
 9766      (begin
 9767        (move-opnd-to-loc68 first-opnd pdec-sp (sn-opnd loc sn))
 9768        (emit-moveq 8 dtemp1)
 9769        (emit-divsl.l pinc-sp dtemp1 dtemp1)
 9770        (emit-asl.l (make-imm 3) dtemp1)
 9771        (emit-and.w (make-imm -8) dtemp1)
 9772        (move-opnd68-to-loc dtemp1 loc sn))
 9773      (let* ((sn-other-opnds (sn-opnds other-opnds sn))
 9774             (sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
 9775        (if (and (reg? loc) (not self-opnds?) (not (eq? loc return-reg)))
 9776            (let ((reg68 (reg->reg68 loc)))
 9777              (if (not (eq? first-opnd loc))
 9778                  (move-opnd-to-loc68 first-opnd reg68 sn-other-opnds))
 9779              (gen-div-in-place other-opnds reg68 sn))
 9780            (begin
 9781              (move-opnd-to-loc68
 9782               first-opnd
 9783               dtemp1
 9784               (sn-opnd loc sn-other-opnds))
 9785              (gen-div-in-place other-opnds dtemp1 (sn-opnd loc sn))
 9786              (move-opnd68-to-loc dtemp1 loc sn))))))
 9787(define (gen-rem first-opnd second-opnd loc sn)
 9788  (let* ((sn-loc (sn-opnd loc sn))
 9789         (sn-second-opnd (sn-opnd second-opnd sn-loc)))
 9790    (move-opnd-to-loc68 first-opnd dtemp1 sn-second-opnd)
 9791    (let ((opnd68 (opnd->opnd68 second-opnd #f sn-loc))
 9792          (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
 9793                     (reg->reg68 loc)
 9794                     false-reg)))
 9795      (make-top-of-frame-if-stk-opnd68 opnd68 sn-loc)
 9796      (let ((opnd68* (if (areg? opnd68)
 9797                         (begin (emit-move.l opnd68 reg68) reg68)
 9798                         (opnd68->true-opnd68 opnd68 sn-loc))))
 9799        (emit-divsl.l opnd68* reg68 dtemp1))
 9800      (move-opnd68-to-loc reg68 loc sn)
 9801      (if (not (and (reg? loc) (not (eq? loc return-reg))))
 9802          (emit-move.l (make-imm bits-false) false-reg)))))
 9803(define (gen-mod first-opnd second-opnd loc sn)
 9804  (let* ((sn-loc (sn-opnd loc sn))
 9805         (sn-first-opnd (sn-opnd first-opnd sn-loc))
 9806         (sn-second-opnd (sn-opnd second-opnd sn-first-opnd))
 9807         (opnd68 (opnd->opnd68 second-opnd #f sn-second-opnd)))
 9808    (define (general-case)
 9809      (let ((lbl1 (new-lbl!))
 9810            (lbl2 (new-lbl!))
 9811            (lbl3 (new-lbl!))
 9812            (opnd68** (opnd68->true-opnd68 opnd68 sn-second-opnd))
 9813            (opnd68* (opnd68->true-opnd68
 9814                      (opnd->opnd68 first-opnd #f sn-second-opnd)
 9815                      sn-second-opnd)))
 9816        (move-opnd68-to-loc68 opnd68* dtemp1)
 9817        (move-opnd68-to-loc68 opnd68** false-reg)
 9818        (emit-divsl.l false-reg false-reg dtemp1)
 9819        (emit-move.l false-reg false-reg)
 9820        (emit-beq lbl3)
 9821        (move-opnd68-to-loc68 opnd68* dtemp1)
 9822        (emit-bmi lbl1)
 9823        (move-opnd68-to-loc68 opnd68** dtemp1)
 9824        (emit-bpl lbl3)
 9825        (emit-bra lbl2)
 9826        (emit-label lbl1)
 9827        (move-opnd68-to-loc68 opnd68** dtemp1)
 9828        (emit-bmi lbl3)
 9829        (emit-label lbl2)
 9830        (emit-add.l dtemp1 false-reg)
 9831        (emit-label lbl3)
 9832        (move-opnd68-to-loc false-reg loc sn)
 9833        (emit-move.l (make-imm bits-false) false-reg)))
 9834    (make-top-of-frame-if-stk-opnd68 opnd68 sn-first-opnd)
 9835    (if (imm? opnd68)
 9836        (let ((n (quotient (imm-val opnd68) 8)))
 9837          (if (> n 0)
 9838              (let ((shift (power-of-2 n)))
 9839                (if shift
 9840                    (let ((reg68 (if (and (reg? loc)
 9841                                          (not (eq? loc return-reg)))
 9842                                     (reg->reg68 loc)
 9843                                     dtemp1)))
 9844                      (move-opnd-to-loc68 first-opnd reg68 sn-loc)
 9845                      (emit-and.l (make-imm (* (- n 1) 8)) reg68)
 9846                      (move-opnd68-to-loc reg68 loc sn))
 9847                    (general-case)))
 9848              (general-case)))
 9849        (general-case))))
 9850(define (gen-op emit-op dst-ok?)
 9851  (define (gen-op-in-place opnds loc68 sn)
 9852    (if (not (null? opnds))
 9853        (let* ((first-opnd (car opnds))
 9854               (other-opnds (cdr opnds))
 9855               (sn-other-opnds (sn-opnds other-opnds sn))
 9856               (sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
 9857               (opnd68 (opnd->opnd68
 9858                        first-opnd
 9859                        (temp-in-opnd68 loc68)
 9860                        (sn-opnd68 loc68 sn))))
 9861          (make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn-other-opnds)
 9862          (if (imm? opnd68)
 9863              (emit-op opnd68 (opnd68->true-opnd68 loc68 sn-other-opnds))
 9864              (let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
 9865                (if (or (dreg? opnd68) (dst-ok? loc68))
 9866                    (emit-op opnd68*
 9867                             (opnd68->true-opnd68 loc68 sn-other-opnds))
 9868                    (begin
 9869                      (move-opnd68-to-loc68 opnd68* dtemp1)
 9870                      (emit-op dtemp1
 9871                               (opnd68->true-opnd68 loc68 sn-other-opnds))))))
 9872          (gen-op-in-place other-opnds loc68 sn))))
 9873  (lambda (self-opnds other-opnds loc sn self?)
 9874    (let* ((opnds (append self-opnds other-opnds))
 9875           (first-opnd (car opnds))
 9876           (other-opnds (cdr opnds))
 9877           (sn-other-opnds (sn-opnds other-opnds sn))
 9878           (sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
 9879      (if (<= (length self-opnds) 1)
 9880          (let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
 9881            (if self?
 9882                (gen-op-in-place opnds loc68 sn)
 9883                (begin
 9884                  (move-opnd-to-loc68 first-opnd loc68 sn-other-opnds)
 9885                  (gen-op-in-place other-opnds loc68 sn))))
 9886          (begin
 9887            (move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn-other-opnds))
 9888            (gen-op-in-place other-opnds dtemp1 (sn-opnd loc sn))
 9889            (if self?
 9890                (let ((loc68 (loc->loc68 loc dtemp1 sn)))
 9891                  (make-top-of-frame-if-stk-opnd68 loc68 sn)
 9892                  (emit-op dtemp1 (opnd68->true-opnd68 loc68 sn)))
 9893                (move-opnd68-to-loc dtemp1 loc sn)))))))
 9894(define gen-logior (gen-op emit-or.l dreg?))
 9895(define gen-logxor (gen-op emit-eor.l (lambda (x) #f)))
 9896(define gen-logand (gen-op emit-and.l dreg?))
 9897(define (gen-shift right-shift)
 9898  (lambda (opnds loc sn)
 9899    (let ((sn-loc (sn-opnd loc sn)))
 9900      (let* ((opnd1 (car opnds))
 9901             (opnd2 (cadr opnds))
 9902             (sn-opnd1 (sn-opnd opnd1 sn-loc))
 9903             (o2 (opnd->opnd68 opnd2 #f sn-opnd1)))
 9904        (make-top-of-frame-if-stk-opnd68 o2 sn-opnd1)
 9905        (if (imm? o2)
 9906            (let* ((reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
 9907                              (reg->reg68 loc)
 9908                              dtemp1))
 9909                   (n (quotient (imm-val o2) 8))
 9910                   (emit-shft (if (> n 0) emit-lsl.l right-shift)))
 9911              (move-opnd-to-loc68 opnd1 reg68 sn-loc)
 9912              (let loop ((i (min (abs n) 29)))
 9913                (if (> i 0)
 9914                    (begin
 9915                      (emit-shft (make-imm (min i 8)) reg68)
 9916                      (loop (- i 8)))))
 9917              (if (< n 0) (emit-and.w (make-imm -8) reg68))
 9918              (move-opnd68-to-loc reg68 loc sn))
 9919            (let* ((reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
 9920                              (reg->reg68 loc)
 9921                              dtemp1))
 9922                   (reg68* (if (and (reg? loc) (not (eq? loc return-reg)))
 9923                               dtemp1
 9924                               false-reg))
 9925                   (lbl1 (new-lbl!))
 9926                   (lbl2 (new-lbl!)))
 9927              (emit-move.l (opnd68->true-opnd68 o2 sn-opnd1) reg68*)
 9928              (move-opnd-to-loc68 opnd1 reg68 sn-loc)
 9929              (emit-asr.l (make-imm 3) reg68*)
 9930              (emit-bmi lbl1)
 9931              (emit-lsl.l reg68* reg68)
 9932              (emit-bra lbl2)
 9933              (emit-label lbl1)
 9934              (emit-neg.l reg68*)
 9935              (right-shift reg68* reg68)
 9936              (emit-and.w (make-imm -8) reg68)
 9937              (emit-label lbl2)
 9938              (move-opnd68-to-loc reg68 loc sn)
 9939              (if (not (and (reg? loc) (not (eq? loc return-reg))))
 9940                  (emit-move.l (make-imm bits-false) false-reg))))))))
 9941(define (flo-oper oper1 oper2 opnds loc sn)
 9942  (gen-guarantee-space 2)
 9943  (move-opnd-to-loc68
 9944   (car opnds)
 9945   atemp1
 9946   (sn-opnds (cdr opnds) (sn-opnd loc sn)))
 9947  (oper1 (make-disp* atemp1 (- type-flonum)) ftemp1)
 9948  (let loop ((opnds (cdr opnds)))
 9949    (if (not (null? opnds))
 9950        (let* ((opnd (car opnds))
 9951               (other-opnds (cdr opnds))
 9952               (sn-other-opnds (sn-opnds other-opnds sn)))
 9953          (move-opnd-to-loc68 opnd atemp1 sn-other-opnds)
 9954          (oper2 (make-disp* atemp1 (- type-flonum)) ftemp1)
 9955          (loop (cdr opnds)))))
 9956  (add-n-to-loc68 (* -2 pointer-size) heap-reg)
 9957  (emit-fmov.dx ftemp1 (make-ind heap-reg))
 9958  (let ((reg68 (if (reg? loc) (reg->reg68 loc) atemp1)))
 9959    (emit-move.l heap-reg reg68)
 9960    (emit-addq.l type-flonum reg68))
 9961  (if (not (reg? loc)) (move-opnd68-to-loc atemp1 loc sn)))
 9962(define (gen-make-placeholder opnds loc sn)
 9963  (let ((sn-loc (sn-opnd loc sn)))
 9964    (let ((opnd (car opnds)))
 9965      (gen-guarantee-space 4)
 9966      (emit-clr.l (make-pdec heap-reg))
 9967      (move-opnd-to-loc68 opnd (make-pdec heap-reg) sn-loc)
 9968      (emit-move.l null-reg (make-pdec heap-reg))
 9969      (move-opnd68-to-loc68 heap-reg atemp2)
 9970      (emit-addq.l (modulo (- type-placeholder type-pair) 8) atemp2)
 9971      (emit-move.l atemp2 (make-pdec heap-reg))
 9972      (move-opnd68-to-loc atemp2 loc sn))))
 9973(define (gen-subprocedure-id opnds loc sn)
 9974  (let ((sn-loc (sn-opnd loc sn))
 9975        (opnd (car opnds))
 9976        (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
 9977                   (reg->reg68 loc)
 9978                   dtemp1)))
 9979    (move-opnd-to-loc68 opnd atemp1 sn-loc)
 9980    (move-n-to-loc68 32768 reg68)
 9981    (emit-sub.w (make-disp* atemp1 -2) reg68)
 9982    (move-opnd68-to-loc reg68 loc sn)))
 9983(define (gen-subprocedure-parent opnds loc sn)
 9984  (let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
 9985    (move-opnd-to-loc68 opnd atemp1 sn-loc)
 9986    (emit-add.w (make-disp* atemp1 -2) atemp1)
 9987    (add-n-to-loc68 -32768 atemp1)
 9988    (move-opnd68-to-loc atemp1 loc sn)))
 9989(define (gen-return-fs opnds loc sn)
 9990  (let ((sn-loc (sn-opnd loc sn))
 9991        (opnd (car opnds))
 9992        (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
 9993                   (reg->reg68 loc)
 9994                   dtemp1))
 9995        (lbl (new-lbl!)))
 9996    (move-opnd-to-loc68 opnd atemp1 sn-loc)
 9997    (emit-moveq 0 reg68)
 9998    (emit-move.w (make-disp* atemp1 -6) reg68)
 9999    (emit-beq lbl)
10000    (emit-and.w (make-imm 32767) reg68)
10001    (emit-subq.l 8 reg68)
10002    (emit-label lbl)
10003    (emit-addq.l 8 reg68)
10004    (emit-asl.l (make-imm 1) reg68)
10005    (move-opnd68-to-loc reg68 loc sn)))
10006(define (gen-return-link opnds loc sn)
10007  (let ((sn-loc (sn-opnd loc sn))
10008        (opnd (car opnds))
10009        (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10010                   (reg->reg68 loc)
10011                   dtemp1))
10012        (lbl (new-lbl!)))
10013    (move-opnd-to-loc68 opnd atemp1 sn-loc)
10014    (emit-moveq 0 reg68)
10015    (emit-move.w (make-disp* atemp1 -6) reg68)
10016    (emit-beq lbl)
10017    (emit-and.w (make-imm 32767) reg68)
10018    (emit-subq.l 8 reg68)
10019    (emit-label lbl)
10020    (emit-addq.l 8 reg68)
10021    (emit-sub.w (make-disp* atemp1 -4) reg68)
10022    (emit-asl.l (make-imm 1) reg68)
10023    (move-opnd68-to-loc reg68 loc sn)))
10024(define (gen-procedure-info opnds loc sn)
10025  (let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
10026    (move-opnd-to-loc68 opnd atemp1 sn-loc)
10027    (emit-add.w (make-disp* atemp1 -2) atemp1)
10028    (move-opnd68-to-loc (make-disp* atemp1 (- 32768 6)) loc sn)))
10029(define (gen-guarantee-space n)
10030  (set! pointers-allocated (+ pointers-allocated n))
10031  (if (> pointers-allocated heap-allocation-fudge)
10032      (begin (gen-guarantee-fudge) (set! pointers-allocated n))))
10033(define (gen-guarantee-fudge)
10034  (if (> pointers-allocated 0)
10035      (let ((lbl (new-lbl!)))
10036        (emit-cmp.l heap-lim-slot heap-reg)
10037        (emit-bcc lbl)
10038        (gen-trap instr-source entry-frame #f #f heap-alloc1-trap lbl)
10039        (set! pointers-allocated 0))))
10040(define pointers-allocated '())
10041(define (gen-type opnds loc sn)
10042  (let* ((sn-loc (sn-opnd loc sn))
10043         (opnd (car opnds))
10044         (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10045                    (reg->reg68 loc)
10046                    dtemp1)))
10047    (move-opnd-to-loc68 opnd reg68 sn-loc)
10048    (emit-and.l (make-imm 7) reg68)
10049    (emit-asl.l (make-imm 3) reg68)
10050    (move-opnd68-to-loc reg68 loc sn)))
10051(define (gen-type-cast opnds loc sn)
10052  (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
10053    (let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
10054      (let* ((sn-loc (if (and loc (not (eq? first-opnd loc))) sn-loc sn))
10055             (o1 (opnd->opnd68 first-opnd #f (sn-opnd second-opnd sn-loc)))
10056             (o2 (opnd->opnd68 second-opnd (temp-in-opnd68 o1) sn-loc))
10057             (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10058                        (reg->reg68 loc)
10059                        dtemp1)))
10060        (make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
10061        (move-opnd68-to-loc68
10062         (opnd68->true-opnd68 o1 (sn-opnd68 o2 sn-loc))
10063         reg68)
10064        (emit-and.w (make-imm -8) reg68)
10065        (if (imm? o2)
10066            (let ((n (quotient (imm-val o2) 8)))
10067              (if (> n 0) (emit-addq.w n reg68)))
10068            (begin
10069              (move-opnd68-to-loc68 (opnd68->true-opnd68 o2 sn-loc) atemp1)
10070              (emit-exg atemp1 reg68)
10071              (emit-asr.l (make-imm 3) reg68)
10072              (emit-add.l atemp1 reg68)))
10073        (move-opnd68-to-loc reg68 loc sn)))))
10074(define (gen-subtype opnds loc sn)
10075  (let ((sn-loc (sn-opnd loc sn))
10076        (opnd (car opnds))
10077        (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10078                   (reg->reg68 loc)
10079                   dtemp1)))
10080    (move-opnd-to-loc68 opnd atemp1 sn-loc)
10081    (emit-moveq 0 reg68)
10082    (emit-move.b (make-ind atemp1) reg68)
10083    (move-opnd68-to-loc reg68 loc sn)))
10084(define (gen-subtype-set! opnds loc sn)
10085  (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
10086    (let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
10087      (let* ((sn-loc (if (and loc (not (eq? first-opnd loc))) sn-loc sn))
10088             (o1 (opnd->opnd68 first-opnd #f (sn-opnd second-opnd sn-loc)))
10089             (o2 (opnd->opnd68 second-opnd (temp-in-opnd68 o1) sn-loc)))
10090        (make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
10091        (move-opnd68-to-loc68
10092         (opnd68->true-opnd68 o1 (sn-opnd68 o2 sn-loc))
10093         atemp1)
10094        (if (imm? o2)
10095            (emit-move.b (make-imm (imm-val o2)) (make-ind atemp1))
10096            (begin
10097              (move-opnd68-to-loc68 (opnd68->true-opnd68 o2 sn-loc) dtemp1)
10098              (emit-move.b dtemp1 (make-ind atemp1))))
10099        (if (and loc (not (eq? first-opnd loc)))
10100            (move-opnd68-to-loc atemp1 loc sn))))))
10101(define (vector-select kind vector string vector8 vector16)
10102  (case kind
10103    ((string) string)
10104    ((vector8) vector8)
10105    ((vector16) vector16)
10106    (else vector)))
10107(define (obj-vector? kind) (vector-select kind #t #f #f #f))
10108(define (make-gen-vector kind)
10109  (lambda (opnds loc sn)
10110    (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
10111      (let* ((n (length opnds))
10112             (bytes (+ pointer-size
10113                       (* (vector-select kind 4 1 1 2)
10114                          (+ n (if (eq? kind 'string) 1 0)))))
10115             (adjust (modulo (- bytes) 8)))
10116        (gen-guarantee-space
10117         (quotient (* (quotient (+ bytes (- 8 1)) 8) 8) pointer-size))
10118        (if (not (= adjust 0)) (emit-subq.l adjust heap-reg))
10119        (if (eq? kind 'string) (emit-move.b (make-imm 0) (make-pdec heap-reg)))
10120        (let loop ((opnds (reverse opnds)))
10121          (if (pair? opnds)
10122              (let* ((o (car opnds)) (sn-o (sn-opnds (cdr opnds) sn-loc)))
10123                (if (eq? kind 'vector)
10124                    (move-opnd-to-loc68 o (make-pdec heap-reg) sn-o)
10125                    (begin
10126                      (move-opnd-to-loc68 o dtemp1 sn-o)
10127                      (emit-asr.l (make-imm 3) dtemp1)
10128                      (if (eq? kind 'vector16)
10129                          (emit-move.w dtemp1 (make-pdec heap-reg))
10130                          (emit-move.b dtemp1 (make-pdec heap-reg)))))
10131                (loop (cdr opnds)))))
10132        (emit-move.l
10133         (make-imm
10134          (+ (* 256 (- bytes pointer-size))
10135             (* 8 (if (eq? kind 'vector) subtype-vector subtype-string))))
10136         (make-pdec heap-reg))
10137        (if loc
10138            (begin
10139              (emit-lea (make-disp* heap-reg type-subtyped) atemp2)
10140              (move-opnd68-to-loc atemp2 loc sn)))))))
10141(define (make-gen-vector-length kind)
10142  (lambda (opnds loc sn)
10143    (let ((sn-loc (sn-opnd loc sn))
10144          (opnd (car opnds))
10145          (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10146                     (reg->reg68 loc)
10147                     dtemp1)))
10148      (move-opnd-to-loc68 opnd atemp1 sn-loc)
10149      (move-opnd68-to-loc68 (make-disp* atemp1 (- type-subtyped)) reg68)
10150      (emit-lsr.l (make-imm (vector-select kind 7 5 5 6)) reg68)
10151      (if (not (eq? kind 'vector))
10152          (begin
10153            (emit-and.w (make-imm -8) reg68)
10154            (if (eq? kind 'string) (emit-subq.l 8 reg68))))
10155      (move-opnd68-to-loc reg68 loc sn))))
10156(define (make-gen-vector-ref kind)
10157  (lambda (opnds loc sn)
10158    (let ((sn-loc (sn-opnd loc sn)))
10159      (let ((first-opnd (car opnds))
10160            (second-opnd (cadr opnds))
10161            (reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10162                       (reg->reg68 loc)
10163                       dtemp1)))
10164        (let* ((o2 (opnd->opnd68 second-opnd #f (sn-opnd first-opnd sn-loc)))
10165               (o1 (opnd->opnd68 first-opnd (temp-in-opnd68 o2) sn-loc)))
10166          (make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
10167          (let* ((offset (if (eq? kind 'closure)
10168                             (- pointer-size type-procedure)
10169                             (- pointer-size type-subtyped)))
10170                 (loc68 (if (imm? o2)
10171                            (begin
10172                              (move-opnd68-to-loc68
10173                               (opnd68->true-opnd68 o1 sn-loc)
10174                               atemp1)
10175                              (make-disp*
10176                               atemp1
10177                               (+ (quotient
10178                                   (imm-val o2)
10179                                   (vector-select kind 2 8 8 4))
10180                                  offset)))
10181                            (begin
10182                              (move-opnd68-to-loc68
10183                               (opnd68->true-opnd68 o2 (sn-opnd68 o1 sn-loc))
10184                               dtemp1)
10185                              (emit-asr.l
10186                               (make-imm (vector-select kind 1 3 3 2))
10187                               dtemp1)
10188                              (move-opnd68-to-loc68
10189                               (opnd68->true-opnd68 o1 sn-loc)
10190                               atemp1)
10191                              (if (and (identical-opnd68? reg68 dtemp1)
10192                                       (not (obj-vector? kind)))
10193                                  (begin
10194                                    (emit-move.l dtemp1 atemp2)
10195                                    (make-inx atemp1 atemp2 offset))
10196                                  (make-inx atemp1 dtemp1 offset))))))
10197            (if (not (obj-vector? kind)) (emit-moveq 0 reg68))
10198            (case kind
10199              ((string vector8) (emit-move.b loc68 reg68))
10200              ((vector16) (emit-move.w loc68 reg68))
10201              (else (emit-move.l loc68 reg68)))
10202            (if (not (obj-vector? kind))
10203                (begin
10204                  (emit-asl.l (make-imm 3) reg68)
10205                  (if (eq? kind 'string) (emit-addq.w type-special reg68))))
10206            (move-opnd68-to-loc reg68 loc sn)))))))
10207(define (make-gen-vector-set! kind)
10208  (lambda (opnds loc sn)
10209    (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
10210      (let ((first-opnd (car opnds))
10211            (second-opnd (cadr opnds))
10212            (third-opnd (caddr opnds)))
10213        (let* ((sn-loc (if (and loc (not (eq? first-opnd loc)))
10214                           (sn-opnd first-opnd sn-loc)
10215                           sn))
10216               (sn-third-opnd (sn-opnd third-opnd sn-loc))
10217               (o2 (opnd->opnd68
10218                    second-opnd
10219                    #f
10220                    (sn-opnd first-opnd sn-third-opnd)))
10221               (o1 (opnd->opnd68
10222                    first-opnd
10223                    (temp-in-opnd68 o2)
10224                    sn-third-opnd)))
10225          (make-top-of-frame-if-stk-opnds68 o1 o2 sn-third-opnd)
10226          (let* ((offset (if (eq? kind 'closure)
10227                             (- pointer-size type-procedure)
10228                             (- pointer-size type-subtyped)))
10229                 (loc68 (if (imm? o2)
10230                            (begin
10231                              (move-opnd68-to-loc68
10232                               (opnd68->true-opnd68 o1 sn-third-opnd)
10233                               atemp1)
10234                              (make-disp*
10235                               atemp1
10236                               (+ (quotient
10237                                   (imm-val o2)
10238                                   (vector-select kind 2 8 8 4))
10239                                  offset)))
10240                            (begin
10241                              (move-opnd68-to-loc68
10242                               (opnd68->true-opnd68 o2 (sn-opnd68 o1 sn-loc))
10243                               dtemp1)
10244                              (emit-asr.l
10245                               (make-imm (vector-select kind 1 3 3 2))
10246                               dtemp1)
10247                              (move-opnd68-to-loc68
10248                               (opnd68->true-opnd68 o1 sn-loc)
10249                               atemp1)
10250                              (if (obj-vector? kind)
10251                                  (make-inx atemp1 dtemp1 offset)
10252                                  (begin
10253                                    (emit-move.l dtemp1 atemp2)
10254                                    (make-inx atemp1 atemp2 offset)))))))
10255            (if (obj-vector? kind)
10256                (move-opnd-to-loc68 third-opnd loc68 sn-loc)
10257                (begin
10258                  (move-opnd-to-loc68 third-opnd dtemp1 sn-loc)
10259                  (emit-asr.l (make-imm 3) dtemp1)
10260                  (if (eq? kind 'vector16)
10261                      (emit-move.w dtemp1 loc68)
10262                      (emit-move.b dtemp1 loc68))))
10263            (if (and loc (not (eq? first-opnd loc)))
10264                (copy-opnd-to-loc first-opnd loc sn))))))))
10265(define (make-gen-vector-shrink! kind)
10266  (lambda (opnds loc sn)
10267    (let ((sn-loc (if loc (sn-opnd loc sn) sn)))
10268      (let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
10269        (let* ((sn-loc (if (and loc (not (eq? first-opnd loc)))
10270                           (sn-opnd first-opnd sn-loc)
10271                           sn))
10272               (o2 (opnd->opnd68 second-opnd #f (sn-opnd first-opnd sn-loc)))
10273               (o1 (opnd->opnd68 first-opnd (temp-in-opnd68 o2) sn-loc)))
10274          (make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
10275          (move-opnd68-to-loc68
10276           (opnd68->true-opnd68 o2 (sn-opnd68 o1 sn-loc))
10277           dtemp1)
10278          (emit-move.l (opnd68->true-opnd68 o1 sn-loc) atemp1)
10279          (if (eq? kind 'string)
10280              (begin
10281                (emit-asr.l (make-imm 3) dtemp1)
10282                (emit-move.b
10283                 (make-imm 0)
10284                 (make-inx atemp1 dtemp1 (- pointer-size type-subtyped)))
10285                (emit-addq.l 1 dtemp1)
10286                (emit-asl.l (make-imm 8) dtemp1))
10287              (emit-asl.l (make-imm (vector-select kind 7 5 5 6)) dtemp1))
10288          (emit-move.b (make-ind atemp1) dtemp1)
10289          (emit-move.l dtemp1 (make-disp* atemp1 (- type-subtyped)))
10290          (if (and loc (not (eq? first-opnd loc)))
10291              (move-opnd68-to-loc atemp1 loc sn)))))))
10292(define (gen-eq-test bits not? opnds lbl fs)
10293  (gen-compare* (opnd->opnd68 (car opnds) #f fs) (make-imm bits) fs)
10294  (if not? (emit-bne lbl) (emit-beq lbl)))
10295(define (gen-compare opnd1 opnd2 fs)
10296  (let* ((o1 (opnd->opnd68 opnd1 #f (sn-opnd opnd2 fs)))
10297         (o2 (opnd->opnd68 opnd2 (temp-in-opnd68 o1) fs)))
10298    (gen-compare* o1 o2 fs)))
10299(define (gen-compare* o1 o2 fs)
10300  (make-top-of-frame-if-stk-opnds68 o1 o2 fs)
10301  (let ((order-1-2
10302         (cond ((imm? o1)
10303                (cmp-n-to-opnd68 (imm-val o1) (opnd68->true-opnd68 o2 fs)))
10304               ((imm? o2)
10305                (not (cmp-n-to-opnd68
10306                      (imm-val o2)
10307                      (opnd68->true-opnd68 o1 fs))))
10308               ((reg68? o1) (emit-cmp.l (opnd68->true-opnd68 o2 fs) o1) #f)
10309               ((reg68? o2) (emit-cmp.l (opnd68->true-opnd68 o1 fs) o2) #t)
10310               (else
10311                (emit-move.l (opnd68->true-opnd68 o1 (sn-opnd68 o2 fs)) dtemp1)
10312                (emit-cmp.l (opnd68->true-opnd68 o2 fs) dtemp1)
10313                #f))))
10314    (shrink-frame fs)
10315    order-1-2))
10316(define (gen-compares branch< branch>= branch> branch<= not? opnds lbl fs)
10317  (gen-compares*
10318   gen-compare
10319   branch<
10320   branch>=
10321   branch>
10322   branch<=
10323   not?
10324   opnds
10325   lbl
10326   fs))
10327(define (gen-compares*
10328         gen-comp
10329         branch<
10330         branch>=
10331         branch>
10332         branch<=
10333         not?
10334         opnds
10335         lbl
10336         fs)
10337  (define (gen-compare-sequence opnd1 opnd2 rest)
10338    (if (null? rest)
10339        (if (gen-comp opnd1 opnd2 fs)
10340            (if not? (branch<= lbl) (branch> lbl))
10341            (if not? (branch>= lbl) (branch< lbl)))
10342        (let ((order-1-2
10343               (gen-comp opnd1 opnd2 (sn-opnd opnd2 (sn-opnds rest fs)))))
10344          (if (= current-fs fs)
10345              (if not?
10346                  (begin
10347                    (if order-1-2 (branch<= lbl) (branch>= lbl))
10348                    (gen-compare-sequence opnd2 (car rest) (cdr rest)))
10349                  (let ((exit-lbl (new-lbl!)))
10350                    (if order-1-2 (branch<= exit-lbl) (branch>= exit-lbl))
10351                    (gen-compare-sequence opnd2 (car rest) (cdr rest))
10352                    (emit-label exit-lbl)))
10353              (if not?
10354                  (let ((next-lbl (new-lbl!)))
10355                    (if order-1-2 (branch> next-lbl) (branch< next-lbl))
10356                    (shrink-frame fs)
10357                    (emit-bra lbl)
10358                    (emit-label next-lbl)
10359                    (gen-compare-sequence opnd2 (car rest) (cdr rest)))
10360                  (let* ((next-lbl (new-lbl!)) (exit-lbl (new-lbl!)))
10361                    (if order-1-2 (branch> next-lbl) (branch< next-lbl))
10362                    (shrink-frame fs)
10363                    (emit-bra exit-lbl)
10364                    (emit-label next-lbl)
10365                    (gen-compare-sequence opnd2 (car rest) (cdr rest))
10366                    (emit-label exit-lbl)))))))
10367  (if (or (null? opnds) (null? (cdr opnds)))
10368      (begin (shrink-frame fs) (if (not not?) (emit-bra lbl)))
10369      (gen-compare-sequence (car opnds) (cadr opnds) (cddr opnds))))
10370(define (gen-compare-flo opnd1 opnd2 fs)
10371  (let* ((o1 (opnd->opnd68 opnd1 #f (sn-opnd opnd2 fs)))
10372         (o2 (opnd->opnd68 opnd2 (temp-in-opnd68 o1) fs)))
10373    (make-top-of-frame-if-stk-opnds68 o1 o2 fs)
10374    (emit-move.l (opnd68->true-opnd68 o1 (sn-opnd68 o2 fs)) atemp1)
10375    (emit-move.l (opnd68->true-opnd68 o2 fs) atemp2)
10376    (emit-fmov.dx (make-disp* atemp2 (- type-flonum)) ftemp1)
10377    (emit-fcmp.dx (make-disp* atemp1 (- type-flonum)) ftemp1)
10378    #t))
10379(define (gen-compares-flo branch< branch>= branch> branch<= not? opnds lbl fs)
10380  (gen-compares*
10381   gen-compare-flo
10382   branch<
10383   branch>=
10384   branch>
10385   branch<=
10386   not?
10387   opnds
10388   lbl
10389   fs))
10390(define (gen-type-test tag not? opnds lbl fs)
10391  (let ((opnd (car opnds)))
10392    (let ((o (opnd->opnd68 opnd #f fs)))
10393      (define (mask-test set-reg correction)
10394        (emit-btst
10395         (if (= correction 0)
10396             (if (dreg? o)
10397                 o
10398                 (begin
10399                   (emit-move.l (opnd68->true-opnd68 o fs) dtemp1)
10400                   dtemp1))
10401             (begin
10402               (if (not (eq? o dtemp1))
10403                   (emit-move.l (opnd68->true-opnd68 o fs) dtemp1))
10404               (emit-addq.w correction dtemp1)
10405               dtemp1))
10406         set-reg))
10407      (make-top-of-frame-if-stk-opnd68 o fs)
10408      (cond ((= tag 0)
10409             (if (eq? o dtemp1)
10410                 (emit-and.w (make-imm 7) dtemp1)
10411                 (begin
10412                   (emit-move.l (opnd68->true-opnd68 o fs) dtemp1)
10413                   (emit-and.w (make-imm 7) dtemp1))))
10414            ((= tag type-placeholder) (mask-test placeholder-reg 0))
10415            (else (mask-test pair-reg (modulo (- type-pair tag) 8))))
10416      (shrink-frame fs)
10417      (if not? (emit-bne lbl) (emit-beq lbl)))))
10418(define (gen-subtype-test type not? opnds lbl fs)
10419  (let ((opnd (car opnds)))
10420    (let ((o (opnd->opnd68 opnd #f fs)) (cont-lbl (new-lbl!)))
10421      (make-top-of-frame-if-stk-opnd68 o fs)
10422      (if (not (eq? o dtemp1)) (emit-move.l (opnd68->true-opnd68 o fs) dtemp1))
10423      (emit-move.l dtemp1 atemp1)
10424      (emit-addq.w (modulo (- type-pair type-subtyped) 8) dtemp1)
10425      (emit-btst dtemp1 pair-reg)
10426      (shrink-frame fs)
10427      (if not? (emit-bne lbl) (emit-bne cont-lbl))
10428      (emit-cmp.b (make-imm (* type 8)) (make-ind atemp1))
10429      (if not? (emit-bne lbl) (emit-beq lbl))
10430      (emit-label cont-lbl))))
10431(define (gen-even-test not? opnds lbl fs)
10432  (move-opnd-to-loc68 (car opnds) dtemp1 fs)
10433  (emit-and.w (make-imm 8) dtemp1)
10434  (shrink-frame fs)
10435  (if not? (emit-bne lbl) (emit-beq lbl)))
10436(define (def-spec name specializer-maker)
10437  (let ((proc-name (string->canonical-symbol name)))
10438    (let ((proc (prim-info proc-name)))
10439      (if proc
10440          (proc-obj-specialize-set! proc (specializer-maker proc proc-name))
10441          (compiler-internal-error "def-spec, unknown primitive:" name)))))
10442(define (safe name)
10443  (lambda (proc proc-name)
10444    (let ((spec (get-prim-info name))) (lambda (decls) spec))))
10445(define (unsafe name)
10446  (lambda (proc proc-name)
10447    (let ((spec (get-prim-info name)))
10448      (lambda (decls) (if (not (safe? decls)) spec proc)))))
10449(define (safe-arith fix-name flo-name) (arith #t fix-name flo-name))
10450(define (unsafe-arith fix-name flo-name) (arith #f fix-name flo-name))
10451(define (arith fix-safe? fix-name flo-name)
10452  (lambda (proc proc-name)
10453    (let ((fix-spec (if fix-name (get-prim-info fix-name) proc))
10454          (flo-spec (if flo-name (get-prim-info flo-name) proc)))
10455      (lambda (decls)
10456        (let ((arith (arith-implementation proc-name decls)))
10457          (cond ((eq? arith fixnum-sym)
10458                 (if (or fix-safe? (not (safe? decls))) fix-spec proc))
10459                ((eq? arith flonum-sym) (if (not (safe? decls)) flo-spec proc))
10460                (else proc)))))))
10461(define-apply "##TYPE" #f (lambda (opnds loc sn) (gen-type opnds loc sn)))
10462(define-apply
10463 "##TYPE-CAST"
10464 #f
10465 (lambda (opnds loc sn) (gen-type-cast opnds loc sn)))
10466(define-apply
10467 "##SUBTYPE"
10468 #f
10469 (lambda (opnds loc sn) (gen-subtype opnds loc sn)))
10470(define-apply
10471 "##SUBTYPE-SET!"
10472 #t
10473 (lambda (opnds loc sn) (gen-subtype-set! opnds loc sn)))
10474(define-ifjump
10475 "##NOT"
10476 (lambda (not? opnds lbl fs) (gen-eq-test bits-false not? opnds lbl fs)))
10477(define-ifjump
10478 "##NULL?"
10479 (lambda (not? opnds lbl fs) (gen-eq-test bits-null not? opnds lbl fs)))
10480(define-ifjump
10481 "##UNASSIGNED?"
10482 (lambda (not? opnds lbl fs) (gen-eq-test bits-unass not? opnds lbl fs)))
10483(define-ifjump
10484 "##UNBOUND?"
10485 (lambda (not? opnds lbl fs) (gen-eq-test bits-unbound not? opnds lbl fs)))
10486(define-ifjump
10487 "##EQ?"
10488 (lambda (not? opnds lbl fs)
10489   (gen-compares emit-beq emit-bne emit-beq emit-bne not? opnds lbl fs)))
10490(define-ifjump
10491 "##FIXNUM?"
10492 (lambda (not? opnds lbl fs) (gen-type-test type-fixnum not? opnds lbl fs)))
10493(define-ifjump
10494 "##FLONUM?"
10495 (lambda (not? opnds lbl fs) (gen-type-test type-flonum not? opnds lbl fs)))
10496(define-ifjump
10497 "##SPECIAL?"
10498 (lambda (not? opnds lbl fs) (gen-type-test type-special not? opnds lbl fs)))
10499(define-ifjump
10500 "##PAIR?"
10501 (lambda (not? opnds lbl fs) (gen-type-test type-pair not? opnds lbl fs)))
10502(define-ifjump
10503 "##SUBTYPED?"
10504 (lambda (not? opnds lbl fs) (gen-type-test type-subtyped not? opnds lbl fs)))
10505(define-ifjump
10506 "##PROCEDURE?"
10507 (lambda (not? opnds lbl fs) (gen-type-test type-procedure not? opnds lbl fs)))
10508(define-ifjump
10509 "##PLACEHOLDER?"
10510 (lambda (not? opnds lbl fs)
10511   (gen-type-test type-placeholder not? opnds lbl fs)))
10512(define-ifjump
10513 "##VECTOR?"
10514 (lambda (not? opnds lbl fs)
10515   (gen-subtype-test subtype-vector not? opnds lbl fs)))
10516(define-ifjump
10517 "##SYMBOL?"
10518 (lambda (not? opnds lbl fs)
10519   (gen-subtype-test subtype-symbol not? opnds lbl fs)))
10520(define-ifjump
10521 "##RATNUM?"
10522 (lambda (not? opnds lbl fs)
10523   (gen-subtype-test subtype-ratnum not? opnds lbl fs)))
10524(define-ifjump
10525 "##CPXNUM?"
10526 (lambda (not? opnds lbl fs)
10527   (gen-subtype-test subtype-cpxnum not? opnds lbl fs)))
10528(define-ifjump
10529 "##STRING?"
10530 (lambda (not? opnds lbl fs)
10531   (gen-subtype-test subtype-string not? opnds lbl fs)))
10532(define-ifjump
10533 "##BIGNUM?"
10534 (lambda (not? opnds lbl fs)
10535   (gen-subtype-test subtype-bignum not? opnds lbl fs)))
10536(define-ifjump
10537 "##CHAR?"
10538 (lambda (not? opnds lbl fs)
10539   (let ((opnd (car opnds)))
10540     (let ((o (opnd->opnd68 opnd #f fs)) (cont-lbl (new-lbl!)))
10541       (make-top-of-frame-if-stk-opnd68 o fs)
10542       (emit-move.l (opnd68->true-opnd68 o fs) dtemp1)
10543       (if not? (emit-bmi lbl) (emit-bmi cont-lbl))
10544       (emit-addq.w (modulo (- type-pair type-special) 8) dtemp1)
10545       (emit-btst dtemp1 pair-reg)
10546       (shrink-frame fs)
10547       (if not? (emit-bne lbl) (emit-beq lbl))
10548       (emit-label cont-lbl)))))
10549(define-ifjump
10550 "##CLOSURE?"
10551 (lambda (not? opnds lbl fs)
10552   (move-opnd-to-loc68 (car opnds) atemp1 fs)
10553   (shrink-frame fs)
10554   (emit-cmp.w (make-imm 20153) (make-ind atemp1))
10555   (if not? (emit-bne lbl) (emit-beq lbl))))
10556(define-ifjump
10557 "##SUBPROCEDURE?"
10558 (lambda (not? opnds lbl fs)
10559   (move-opnd-to-loc68 (car opnds) atemp1 fs)
10560   (shrink-frame fs)
10561   (emit-move.w (make-pdec atemp1) dtemp1)
10562   (if not? (emit-bmi lbl) (emit-bpl lbl))))
10563(define-ifjump
10564 "##RETURN-DYNAMIC-ENV-BIND?"
10565 (lambda (not? opnds lbl fs)
10566   (move-opnd-to-loc68 (car opnds) atemp1 fs)
10567   (shrink-frame fs)
10568   (emit-move.w (make-disp* atemp1 -6) dtemp1)
10569   (if not? (emit-bne lbl) (emit-beq lbl))))
10570(define-apply
10571 "##FIXNUM.+"
10572 #f
10573 (lambda (opnds loc sn)
10574   (let ((sn-loc (sn-opnd loc sn)))
10575     (cond ((null? opnds) (copy-opnd-to-loc (make-obj '0) loc sn))
10576           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10577           ((or (reg? loc) (stk? loc))
10578            (commut-oper gen-add opnds loc sn #f '() '()))
10579           (else (gen-add opnds '() loc sn #f))))))
10580(define-apply
10581 "##FIXNUM.-"
10582 #f
10583 (lambda (opnds loc sn)
10584   (let ((sn-loc (sn-opnd loc sn)))
10585     (gen-sub (car opnds)
10586              (cdr opnds)
10587              loc
10588              sn
10589              (any-contains-opnd? loc (cdr opnds))))))
10590(define-apply
10591 "##FIXNUM.*"
10592 #f
10593 (lambda (opnds loc sn)
10594   (let ((sn-loc (sn-opnd loc sn)))
10595     (cond ((null? opnds) (copy-opnd-to-loc (make-obj '1) loc sn))
10596           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10597           ((and (reg? loc) (not (eq? loc return-reg)))
10598            (commut-oper gen-mul opnds loc sn #f '() '()))
10599           (else (gen-mul opnds '() loc sn #f))))))
10600(define-apply
10601 "##FIXNUM.QUOTIENT"
10602 #f
10603 (lambda (opnds loc sn)
10604   (let ((sn-loc (sn-opnd loc sn)))
10605     (gen-div (car opnds)
10606              (cdr opnds)
10607              loc
10608              sn
10609              (any-contains-opnd? loc (cdr opnds))))))
10610(define-apply
10611 "##FIXNUM.REMAINDER"
10612 #f
10613 (lambda (opnds loc sn)
10614   (let ((sn-loc (sn-opnd loc sn)))
10615     (gen-rem (car opnds) (cadr opnds) loc sn))))
10616(define-apply
10617 "##FIXNUM.MODULO"
10618 #f
10619 (lambda (opnds loc sn)
10620   (let ((sn-loc (sn-opnd loc sn)))
10621     (gen-mod (car opnds) (cadr opnds) loc sn))))
10622(define-apply
10623 "##FIXNUM.LOGIOR"
10624 #f
10625 (lambda (opnds loc sn)
10626   (let ((sn-loc (sn-opnd loc sn)))
10627     (cond ((null? opnds) (copy-opnd-to-loc (make-obj '0) loc sn))
10628           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10629           ((or (reg? loc) (stk? loc))
10630            (commut-oper gen-logior opnds loc sn #f '() '()))
10631           (else (gen-logior opnds '() loc sn #f))))))
10632(define-apply
10633 "##FIXNUM.LOGXOR"
10634 #f
10635 (lambda (opnds loc sn)
10636   (let ((sn-loc (sn-opnd loc sn)))
10637     (cond ((null? opnds) (copy-opnd-to-loc (make-obj '0) loc sn))
10638           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10639           ((or (reg? loc) (stk? loc))
10640            (commut-oper gen-logxor opnds loc sn #f '() '()))
10641           (else (gen-logxor opnds '() loc sn #f))))))
10642(define-apply
10643 "##FIXNUM.LOGAND"
10644 #f
10645 (lambda (opnds loc sn)
10646   (let ((sn-loc (sn-opnd loc sn)))
10647     (cond ((null? opnds) (copy-opnd-to-loc (make-obj '-1) loc sn))
10648           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10649           ((or (reg? loc) (stk? loc))
10650            (commut-oper gen-logand opnds loc sn #f '() '()))
10651           (else (gen-logand opnds '() loc sn #f))))))
10652(define-apply
10653 "##FIXNUM.LOGNOT"
10654 #f
10655 (lambda (opnds loc sn)
10656   (let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
10657     (if (and (or (reg? loc) (stk? loc)) (not (eq? loc return-reg)))
10658         (begin
10659           (copy-opnd-to-loc opnd loc sn-loc)
10660           (let ((loc68 (loc->loc68 loc #f sn)))
10661             (make-top-of-frame-if-stk-opnd68 loc68 sn)
10662             (emit-not.l (opnd68->true-opnd68 loc68 sn))
10663             (emit-and.w (make-imm -8) (opnd68->true-opnd68 loc68 sn))))
10664         (begin
10665           (move-opnd-to-loc68 opnd dtemp1 (sn-opnd loc sn))
10666           (emit-not.l dtemp1)
10667           (emit-and.w (make-imm -8) dtemp1)
10668           (move-opnd68-to-loc dtemp1 loc sn))))))
10669(define-apply "##FIXNUM.ASH" #f (gen-shift emit-asr.l))
10670(define-apply "##FIXNUM.LSH" #f (gen-shift emit-lsr.l))
10671(define-ifjump
10672 "##FIXNUM.ZERO?"
10673 (lambda (not? opnds lbl fs) (gen-eq-test 0 not? opnds lbl fs)))
10674(define-ifjump
10675 "##FIXNUM.POSITIVE?"
10676 (lambda (not? opnds lbl fs)
10677   (gen-compares
10678    emit-bgt
10679    emit-ble
10680    emit-blt
10681    emit-bge
10682    not?
10683    (list (car opnds) (make-obj '0))
10684    lbl
10685    fs)))
10686(define-ifjump
10687 "##FIXNUM.NEGATIVE?"
10688 (lambda (not? opnds lbl fs)
10689   (gen-compares
10690    emit-blt
10691    emit-bge
10692    emit-bgt
10693    emit-ble
10694    not?
10695    (list (car opnds) (make-obj '0))
10696    lbl
10697    fs)))
10698(define-ifjump
10699 "##FIXNUM.ODD?"
10700 (lambda (not? opnds lbl fs) (gen-even-test (not not?) opnds lbl fs)))
10701(define-ifjump
10702 "##FIXNUM.EVEN?"
10703 (lambda (not? opnds lbl fs) (gen-even-test not? opnds lbl fs)))
10704(define-ifjump
10705 "##FIXNUM.="
10706 (lambda (not? opnds lbl fs)
10707   (gen-compares emit-beq emit-bne emit-beq emit-bne not? opnds lbl fs)))
10708(define-ifjump
10709 "##FIXNUM.<"
10710 (lambda (not? opnds lbl fs)
10711   (gen-compares emit-blt emit-bge emit-bgt emit-ble not? opnds lbl fs)))
10712(define-ifjump
10713 "##FIXNUM.>"
10714 (lambda (not? opnds lbl fs)
10715   (gen-compares emit-bgt emit-ble emit-blt emit-bge not? opnds lbl fs)))
10716(define-ifjump
10717 "##FIXNUM.<="
10718 (lambda (not? opnds lbl fs)
10719   (gen-compares emit-ble emit-bgt emit-bge emit-blt not? opnds lbl fs)))
10720(define-ifjump
10721 "##FIXNUM.>="
10722 (lambda (not? opnds lbl fs)
10723   (gen-compares emit-bge emit-blt emit-ble emit-bgt not? opnds lbl fs)))
10724(define-apply
10725 "##FLONUM.->FIXNUM"
10726 #f
10727 (lambda (opnds loc sn)
10728   (let ((sn-loc (sn-opnd loc sn)))
10729     (move-opnd-to-loc68 (car opnds) atemp1 sn-loc)
10730     (let ((reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
10731                      (reg->reg68 loc)
10732                      dtemp1)))
10733       (emit-fmov.dx (make-disp* atemp1 (- type-flonum)) ftemp1)
10734       (emit-fmov.l ftemp1 reg68)
10735       (emit-asl.l (make-imm 3) reg68)
10736       (if (not (and (reg? loc) (not (eq? loc return-reg))))
10737           (move-opnd68-to-loc reg68 loc sn))))))
10738(define-apply
10739 "##FLONUM.<-FIXNUM"
10740 #f
10741 (lambda (opnds loc sn)
10742   (gen-guarantee-space 2)
10743   (move-opnd-to-loc68
10744    (car opnds)
10745    dtemp1
10746    (sn-opnds (cdr opnds) (sn-opnd loc sn)))
10747   (emit-asr.l (make-imm 3) dtemp1)
10748   (emit-fmov.l dtemp1 ftemp1)
10749   (add-n-to-loc68 (* -2 pointer-size) heap-reg)
10750   (emit-fmov.dx ftemp1 (make-ind heap-reg))
10751   (let ((reg68 (if (reg? loc) (reg->reg68 loc) atemp1)))
10752     (emit-move.l heap-reg reg68)
10753     (emit-addq.l type-flonum reg68))
10754   (if (not (reg? loc)) (move-opnd68-to-loc atemp1 loc sn))))
10755(define-apply
10756 "##FLONUM.+"
10757 #f
10758 (lambda (opnds loc sn)
10759   (let ((sn-loc (sn-opnd loc sn)))
10760     (cond ((null? opnds) (copy-opnd-to-loc (make-obj inexact-0) loc sn))
10761           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10762           (else (flo-oper emit-fmov.dx emit-fadd.dx opnds loc sn))))))
10763(define-apply
10764 "##FLONUM.*"
10765 #f
10766 (lambda (opnds loc sn)
10767   (let ((sn-loc (sn-opnd loc sn)))
10768     (cond ((null? opnds) (copy-opnd-to-loc (make-obj inexact-+1) loc sn))
10769           ((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
10770           (else (flo-oper emit-fmov.dx emit-fmul.dx opnds loc sn))))))
10771(define-apply
10772 "##FLONUM.-"
10773 #f
10774 (lambda (opnds loc sn)
10775   (let ((sn-loc (sn-opnd loc sn)))
10776     (if (null? (cdr opnds))
10777         (flo-oper emit-fneg.dx #f opnds loc sn)
10778         (flo-oper emit-fmov.dx emit-fsub.dx opnds loc sn)))))
10779(define-apply
10780 "##FLONUM./"
10781 #f
10782 (lambda (opnds loc sn)
10783   (let ((sn-loc (sn-opnd loc sn)))
10784     (if (null? (cdr opnds))
10785         (flo-oper
10786          emit-fmov.dx
10787          emit-fdiv.dx
10788          (cons (make-obj inexact-+1) opnds)
10789          loc
10790          sn)
10791         (flo-oper emit-fmov.dx emit-fdiv.dx opnds loc sn)))))
10792(define-apply
10793 "##FLONUM.ABS"
10794 #f
10795 (lambda (opnds loc sn)
10796   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fabs.dx #f opnds loc sn))))
10797(define-apply
10798 "##FLONUM.TRUNCATE"
10799 #f
10800 (lambda (opnds loc sn)
10801   (let ((sn-loc (sn-opnd loc sn)))
10802     (flo-oper emit-fintrz.dx #f opnds loc sn))))
10803(define-apply
10804 "##FLONUM.ROUND"
10805 #f
10806 (lambda (opnds loc sn)
10807   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fint.dx #f opnds loc sn))))
10808(define-apply
10809 "##FLONUM.EXP"
10810 #f
10811 (lambda (opnds loc sn)
10812   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fetox.dx #f opnds loc sn))))
10813(define-apply
10814 "##FLONUM.LOG"
10815 #f
10816 (lambda (opnds loc sn)
10817   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-flogn.dx #f opnds loc sn))))
10818(define-apply
10819 "##FLONUM.SIN"
10820 #f
10821 (lambda (opnds loc sn)
10822   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fsin.dx #f opnds loc sn))))
10823(define-apply
10824 "##FLONUM.COS"
10825 #f
10826 (lambda (opnds loc sn)
10827   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fcos.dx #f opnds loc sn))))
10828(define-apply
10829 "##FLONUM.TAN"
10830 #f
10831 (lambda (opnds loc sn)
10832   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-ftan.dx #f opnds loc sn))))
10833(define-apply
10834 "##FLONUM.ASIN"
10835 #f
10836 (lambda (opnds loc sn)
10837   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fasin.dx #f opnds loc sn))))
10838(define-apply
10839 "##FLONUM.ACOS"
10840 #f
10841 (lambda (opnds loc sn)
10842   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-facos.dx #f opnds loc sn))))
10843(define-apply
10844 "##FLONUM.ATAN"
10845 #f
10846 (lambda (opnds loc sn)
10847   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fatan.dx #f opnds loc sn))))
10848(define-apply
10849 "##FLONUM.SQRT"
10850 #f
10851 (lambda (opnds loc sn)
10852   (let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fsqrt.dx #f opnds loc sn))))
10853(define-ifjump
10854 "##FLONUM.ZERO?"
10855 (lambda (not? opnds lbl fs)
10856   (gen-compares-flo
10857    emit-fbeq
10858    emit-fbne
10859    emit-fbeq
10860    emit-fbne
10861    not?
10862    (list (car opnds) (make-obj inexact-0))
10863    lbl
10864    fs)))
10865(define-ifjump
10866 "##FLONUM.NEGATIVE?"
10867 (lambda (not? opnds lbl fs)
10868   (gen-compares-flo
10869    emit-fblt
10870    emit-fbge
10871    emit-fbgt
10872    emit-fble
10873    not?
10874    (list (car opnds) (make-obj inexact-0))
10875    lbl
10876    fs)))
10877(define-ifjump
10878 "##FLONUM.POSITIVE?"
10879 (lambda (not? opnds lbl fs)
10880   (gen-compares-flo
10881    emit-fbgt
10882    emit-fble
10883    emit-fblt
10884    emit-fbge
10885    not?
10886    (list (car opnds) (make-obj inexact-0))
10887    lbl
10888    fs)))
10889(define-ifjump
10890 "##FLONUM.="
10891 (lambda (not? opnds lbl fs)
10892   (gen-compares-flo
10893    emit-fbeq
10894    emit-fbne
10895    emit-fbeq
10896    emit-fbne
10897    not?
10898    opnds
10899    lbl
10900    fs)))
10901(define-ifjump
10902 "##FLONUM.<"
10903 (lambda (not? opnds lbl fs)
10904   (gen-compares-flo
10905    emit-fblt
10906    emit-fbge
10907    emit-fbgt
10908    emit-fble
10909    not?
10910    opnds
10911    lbl
10912    fs)))
10913(define-ifjump
10914 "##FLONUM.>"
10915 (lambda (not? opnds lbl fs)
10916   (gen-compares-flo
10917    emit-fbgt
10918    emit-fble
10919    emit-fblt
10920    emit-fbge
10921    not?
10922    opnds
10923    lbl
10924    fs)))
10925(define-ifjump
10926 "##FLONUM.<="
10927 (lambda (not? opnds lbl fs)
10928   (gen-compares-flo
10929    emit-fble
10930    emit-fbgt
10931    emit-fbge
10932    emit-fblt
10933    not?
10934    opnds
10935    lbl
10936    fs)))
10937(define-ifjump
10938 "##FLONUM.>="
10939 (lambda (not? opnds lbl fs)
10940   (gen-compares-flo
10941    emit-fbge
10942    emit-fblt
10943    emit-fble
10944    emit-fbgt
10945    not?
10946    opnds
10947    lbl
10948    fs)))
10949(define-ifjump
10950 "##CHAR=?"
10951 (lambda (not? opnds lbl fs)
10952   (gen-compares emit-beq emit-bne emit-beq emit-bne not? opnds lbl fs)))
10953(define-ifjump
10954 "##CHAR<?"
10955 (lambda (not? opnds lbl fs)
10956   (gen-compares emit-blt emit-bge emit-bgt emit-ble not? opnds lbl fs)))
10957(define-ifjump
10958 "##CHAR>?"
10959 (lambda (not? opnds lbl fs)
10960   (gen-compares emit-bgt emit-ble emit-blt emit-bge not? opnds lbl fs)))
10961(define-ifjump
10962 "##CHAR<=?"
10963 (lambda (not? opnds lbl fs)
10964   (gen-compares emit-ble emit-bgt emit-bge emit-blt not? opnds lbl fs)))
10965(define-ifjump
10966 "##CHAR>=?"
10967 (lambda (not? opnds lbl fs)
10968   (gen-compares emit-bge emit-blt emit-ble emit-bgt not? opnds lbl fs)))
10969(define-apply "##CONS" #f (lambda (opnds loc sn) (gen-cons opnds loc sn)))
10970(define-apply
10971 "##SET-CAR!"
10972 #t
10973 (lambda (opnds loc sn) (gen-set-car! opnds loc sn)))
10974(define-apply
10975 "##SET-CDR!"
10976 #t
10977 (lambda (opnds loc sn) (gen-set-cdr! opnds loc sn)))
10978(define-apply "##CAR" #f (make-gen-apply-c...r 2))
10979(define-apply "##CDR" #f (make-gen-apply-c...r 3))
10980(define-apply "##CAAR" #f (make-gen-apply-c...r 4))
10981(define-apply "##CADR" #f (make-gen-apply-c...r 5))
10982(define-apply "##CDAR" #f (make-gen-apply-c...r 6))
10983(define-apply "##CDDR" #f (make-gen-apply-c...r 7))
10984(define-apply "##CAAAR" #f (make-gen-apply-c...r 8))
10985(define-apply "##CAADR" #f (make-gen-apply-c...r 9))
10986(define-apply "##CADAR" #f (make-gen-apply-c...r 10))
10987(define-apply "##CADDR" #f (make-gen-apply-c...r 11))
10988(define-apply "##CDAAR" #f (make-gen-apply-c...r 12))
10989(define-apply "##CDADR" #f (make-gen-apply-c...r 13))
10990(define-apply "##CDDAR" #f (make-gen-apply-c...r 14))
10991(define-apply "##CDDDR" #f (make-gen-apply-c...r 15))
10992(define-apply "##CAAAAR" #f (make-gen-apply-c...r 16))
10993(define-apply "##CAAADR" #f (make-gen-apply-c...r 17))
10994(define-apply "##CAADAR" #f (make-gen-apply-c...r 18))
10995(define-apply "##CAADDR" #f (make-gen-apply-c...r 19))
10996(define-apply "##CADAAR" #f (make-gen-apply-c...r 20))
10997(define-apply "##CADADR" #f (make-gen-apply-c...r 21))
10998(define-apply "##CADDAR" #f (make-gen-apply-c...r 22))
10999(define-apply "##CADDDR" #f (make-gen-apply-c...r 23))
11000(define-apply "##CDAAAR" #f (make-gen-apply-c...r 24))
11001(define-apply "##CDAADR" #f (make-gen-apply-c...r 25))
11002(define-apply "##CDADAR" #f (make-gen-apply-c...r 26))
11003(define-apply "##CDADDR" #f (make-gen-apply-c...r 27))
11004(define-apply "##CDDAAR" #f (make-gen-apply-c...r 28))
11005(define-apply "##CDDADR" #f (make-gen-apply-c...r 29))
11006(define-apply "##CDDDAR" #f (make-gen-apply-c...r 30))
11007(define-apply "##CDDDDR" #f (make-gen-apply-c...r 31))
11008(define-apply
11009 "##MAKE-CELL"
11010 #f
11011 (lambda (opnds loc sn) (gen-cons (list (car opnds) (make-obj '())) loc sn)))
11012(define-apply "##CELL-REF" #f (make-gen-apply-c...r 2))
11013(define-apply
11014 "##CELL-SET!"
11015 #t
11016 (lambda (opnds loc sn) (gen-set-car! opnds loc sn)))
11017(define-apply "##VECTOR" #f (make-gen-vector 'vector))
11018(define-apply "##VECTOR-LENGTH" #f (make-gen-vector-length 'vector))
11019(define-apply "##VECTOR-REF" #f (make-gen-vector-ref 'vector))
11020(define-apply "##VECTOR-SET!" #t (make-gen-vector-set! 'vector))
11021(define-apply "##VECTOR-SHRINK!" #t (make-gen-vector-shrink! 'vector))
11022(define-apply "##STRING" #f (make-gen-vector 'string))
11023(define-apply "##STRING-LENGTH" #f (make-gen-vector-length 'string))
11024(define-apply "##STRING-REF" #f (make-gen-vector-ref 'string))
11025(define-apply "##STRING-SET!" #t (make-gen-vector-set! 'string))
11026(define-apply "##STRING-SHRINK!" #t (make-gen-vector-shrink! 'string))
11027(define-apply "##VECTOR8" #f (make-gen-vector 'vector8))
11028(define-apply "##VECTOR8-LENGTH" #f (make-gen-vector-length 'vector8))
11029(define-apply "##VECTOR8-REF" #f (make-gen-vector-ref 'vector8))
11030(define-apply "##VECTOR8-SET!" #t (make-gen-vector-set! 'vector8))
11031(define-apply "##VECTOR8-SHRINK!" #t (make-gen-vector-shrink! 'vector8))
11032(define-apply "##VECTOR16" #f (make-gen-vector 'vector16))
11033(define-apply "##VECTOR16-LENGTH" #f (make-gen-vector-length 'vector16))
11034(define-apply "##VECTOR16-REF" #f (make-gen-vector-ref 'vector16))
11035(define-apply "##VECTOR16-SET!" #t (make-gen-vector-set! 'vector16))
11036(define-apply "##VECTOR16-SHRINK!" #t (make-gen-vector-shrink! 'vector16))
11037(define-apply "##CLOSURE-CODE" #f (make-gen-slot-ref 1 type-procedure))
11038(define-apply "##CLOSURE-REF" #f (make-gen-vector-ref 'closure))
11039(define-apply "##CLOSURE-SET!" #t (make-gen-vector-set! 'closure))
11040(define-apply
11041 "##SUBPROCEDURE-ID"
11042 #f
11043 (lambda (opnds loc sn) (gen-subprocedure-id opnds loc sn)))
11044(define-apply
11045 "##SUBPROCEDURE-PARENT"
11046 #f
11047 (lambda (opnds loc sn) (gen-subprocedure-parent opnds loc sn)))
11048(define-apply
11049 "##RETURN-FS"
11050 #f
11051 (lambda (opnds loc sn) (gen-return-fs opnds loc sn)))
11052(define-apply
11053 "##RETURN-LINK"
11054 #f
11055 (lambda (opnds loc sn) (gen-return-link opnds loc sn)))
11056(define-apply
11057 "##PROCEDURE-INFO"
11058 #f
11059 (lambda (opnds loc sn) (gen-procedure-info opnds loc sn)))
11060(define-apply
11061 "##PSTATE"
11062 #f
11063 (lambda (opnds loc sn) (move-opnd68-to-loc pstate-reg loc sn)))
11064(define-apply
11065 "##MAKE-PLACEHOLDER"
11066 #f
11067 (lambda (opnds loc sn) (gen-make-placeholder opnds loc sn)))
11068(define-apply
11069 "##TOUCH"
11070 #t
11071 (lambda (opnds loc sn)
11072   (let ((opnd (car opnds)))
11073     (if loc
11074         (touch-opnd-to-loc opnd loc sn)
11075         (touch-opnd-to-any-reg68 opnd sn)))))
11076(def-spec "NOT" (safe "##NOT"))
11077(def-spec "NULL?" (safe "##NULL?"))
11078(def-spec "EQ?" (safe "##EQ?"))
11079(def-spec "PAIR?" (safe "##PAIR?"))
11080(def-spec "PROCEDURE?" (safe "##PROCEDURE?"))
11081(def-spec "VECTOR?" (safe "##VECTOR?"))
11082(def-spec "SYMBOL?" (safe "##SYMBOL?"))
11083(def-spec "STRING?" (safe "##STRING?"))
11084(def-spec "CHAR?" (safe "##CHAR?"))
11085(def-spec "ZERO?" (safe-arith "##FIXNUM.ZERO?" "##FLONUM.ZERO?"))
11086(def-spec "POSITIVE?" (safe-arith "##FIXNUM.POSITIVE?" "##FLONUM.POSITIVE?"))
11087(def-spec "NEGATIVE?" (safe-arith "##FIXNUM.NEGATIVE?" "##FLONUM.NEGATIVE?"))
11088(def-spec "ODD?" (safe-arith "##FIXNUM.ODD?" #f))
11089(def-spec "EVEN?" (safe-arith "##FIXNUM.EVEN?" #f))
11090(def-spec "+" (unsafe-arith "##FIXNUM.+" "##FLONUM.+"))
11091(def-spec "*" (unsafe-arith "##FIXNUM.*" "##FLONUM.*"))
11092(def-spec "-" (unsafe-arith "##FIXNUM.-" "##FLONUM.-"))
11093(def-spec "/" (unsafe-arith #f "##FLONUM./"))
11094(def-spec "QUOTIENT" (unsafe-arith "##FIXNUM.QUOTIENT" #f))
11095(def-spec "REMAINDER" (unsafe-arith "##FIXNUM.REMAINDER" #f))
11096(def-spec "MODULO" (unsafe-arith "##FIXNUM.MODULO" #f))
11097(def-spec "=" (safe-arith "##FIXNUM.=" "##FLONUM.="))
11098(def-spec "<" (safe-arith "##FIXNUM.<" "##FLONUM.<"))
11099(def-spec ">" (safe-arith "##FIXNUM.>" "##FLONUM.>"))
11100(def-spec "<=" (safe-arith "##FIXNUM.<=" "##FLONUM.<="))
11101(def-spec ">=" (safe-arith "##FIXNUM.>=" "##FLONUM.>="))
11102(def-spec "ABS" (unsafe-arith #f "##FLONUM.ABS"))
11103(def-spec "TRUNCATE" (unsafe-arith #f "##FLONUM.TRUNCATE"))
11104(def-spec "EXP" (unsafe-arith #f "##FLONUM.EXP"))
11105(def-spec "LOG" (unsafe-arith #f "##FLONUM.LOG"))
11106(def-spec "SIN" (unsafe-arith #f "##FLONUM.SIN"))
11107(def-spec "COS" (unsafe-arith #f "##FLONUM.COS"))
11108(def-spec "TAN" (unsafe-arith #f "##FLONUM.TAN"))
11109(def-spec "ASIN" (unsafe-arith #f "##FLONUM.ASIN"))
11110(def-spec "ACOS" (unsafe-arith #f "##FLONUM.ACOS"))
11111(def-spec "ATAN" (unsafe-arith #f "##FLONUM.ATAN"))
11112(def-spec "SQRT" (unsafe-arith #f "##FLONUM.SQRT"))
11113(def-spec "CHAR=?" (safe "##CHAR=?"))
11114(def-spec "CHAR<?" (safe "##CHAR<?"))
11115(def-spec "CHAR>?" (safe "##CHAR>?"))
11116(def-spec "CHAR<=?" (safe "##CHAR<=?"))
11117(def-spec "CHAR>=?" (safe "##CHAR>=?"))
11118(def-spec "CONS" (safe "##CONS"))
11119(def-spec "SET-CAR!" (unsafe "##SET-CAR!"))
11120(def-spec "SET-CDR!" (unsafe "##SET-CDR!"))
11121(def-spec "CAR" (unsafe "##CAR"))
11122(def-spec "CDR" (unsafe "##CDR"))
11123(def-spec "CAAR" (unsafe "##CAAR"))
11124(def-spec "CADR" (unsafe "##CADR"))
11125(def-spec "CDAR" (unsafe "##CDAR"))
11126(def-spec "CDDR" (unsafe "##CDDR"))
11127(def-spec "CAAAR" (unsafe "##CAAAR"))
11128(def-spec "CAADR" (unsafe "##CAADR"))
11129(def-spec "CADAR" (unsafe "##CADAR"))
11130(def-spec "CADDR" (unsafe "##CADDR"))
11131(def-spec "CDAAR" (unsafe "##CDAAR"))
11132(def-spec "CDADR" (unsafe "##CDADR"))
11133(def-spec "CDDAR" (unsafe "##CDDAR"))
11134(def-spec "CDDDR" (unsafe "##CDDDR"))
11135(def-spec "CAAAAR" (unsafe "##CAAAAR"))
11136(def-spec "CAAADR" (unsafe "##CAAADR"))
11137(def-spec "CAADAR" (unsafe "##CAADAR"))
11138(def-spec "CAADDR" (unsafe "##CAADDR"))
11139(def-spec "CADAAR" (unsafe "##CADAAR"))
11140(def-spec "CADADR" (unsafe "##CADADR"))
11141(def-spec "CADDAR" (unsafe "##CADDAR"))
11142(def-spec "CADDDR" (unsafe "##CADDDR"))
11143(def-spec "CDAAAR" (unsafe "##CDAAAR"))
11144(def-spec "CDAADR" (unsafe "##CDAADR"))
11145(def-spec "CDADAR" (unsafe "##CDADAR"))
11146(def-spec "CDADDR" (unsafe "##CDADDR"))
11147(def-spec "CDDAAR" (unsafe "##CDDAAR"))
11148(def-spec "CDDADR" (unsafe "##CDDADR"))
11149(def-spec "CDDDAR" (unsafe "##CDDDAR"))
11150(def-spec "CDDDDR" (unsafe "##CDDDDR"))
11151(def-spec "VECTOR" (safe "##VECTOR"))
11152(def-spec "VECTOR-LENGTH" (unsafe "##VECTOR-LENGTH"))
11153(def-spec "VECTOR-REF" (unsafe "##VECTOR-REF"))
11154(def-spec "VECTOR-SET!" (unsafe "##VECTOR-SET!"))
11155(def-spec "STRING" (safe "##STRING"))
11156(def-spec "STRING-LENGTH" (unsafe "##STRING-LENGTH"))
11157(def-spec "STRING-REF" (unsafe "##STRING-REF"))
11158(def-spec "STRING-SET!" (unsafe "##STRING-SET!"))
11159(def-spec "TOUCH" (safe "##TOUCH"))
11160(let ((targ (make-target 4 'm68000)))
11161  (target-begin!-set! targ (lambda (info-port) (begin! info-port targ)))
11162  (put-target targ))
11163
11164(define input-source-code '
11165(begin
11166(declare (standard-bindings) (fixnum) (not safe) (block))
11167
11168(define (fib n)
11169  (if (< n 2)
11170      n
11171      (+ (fib (- n 1))
11172         (fib (- n 2)))))
11173
11174(define (tak x y z)
11175  (if (not (< y x))
11176      z
11177      (tak (tak (- x 1) y z)
11178           (tak (- y 1) z x)
11179           (tak (- z 1) x y))))
11180
11181(define (ack m n)
11182  (cond ((= m 0) (+ n 1))
11183        ((= n 0) (ack (- m 1) 1))
11184        (else (ack (- m 1) (ack m (- n 1))))))
11185
11186(define (create-x n)
11187  (define result (make-vector n))
11188  (do ((i 0 (+ i 1)))
11189      ((>= i n) result)
11190    (vector-set! result i i)))
11191
11192(define (create-y x)
11193  (let* ((n (vector-length x))
11194         (result (make-vector n)))
11195    (do ((i (- n 1) (- i 1)))
11196        ((< i 0) result)
11197      (vector-set! result i (vector-ref x i)))))
11198
11199(define (my-try n)
11200  (vector-length (create-y (create-x n))))
11201
11202(define (go n)
11203  (let loop ((repeat 100)
11204             (result 0))
11205    (if (> repeat 0)
11206        (loop (- repeat 1) (my-try n))
11207        result)))
11208
11209(+ (fib 20)
11210   (tak 18 12 6)
11211   (ack 3 9)
11212   (go 200000))
11213))
11214
11215(define output-expected '(
11216"|------------------------------------------------------"
11217"| #[primitive #!program] ="
11218"L1:"
11219" cmpw #1,d0"
11220" beq L1000"
11221" TRAP1(9,0)"
11222" LBL_PTR(L1)"
11223"L1000:"
11224" MOVE_PROC(1,a1)"
11225" movl a1,GLOB(fib)"
11226" MOVE_PROC(2,a1)"
11227" movl a1,GLOB(tak)"
11228" MOVE_PROC(3,a1)"
11229" movl a1,GLOB(ack)"
11230" MOVE_PROC(4,a1)"
11231" movl a1,GLOB(create-x)"
11232" MOVE_PROC(5,a1)"
11233" movl a1,GLOB(create-y)"
11234" MOVE_PROC(6,a1)"
11235" movl a1,GLOB(my-try)"
11236" MOVE_PROC(7,a1)"
11237" movl a1,GLOB(go)"
11238" movl a0,sp@-"
11239" movl #160,d1"
11240" lea L2,a0"
11241" dbra d5,L1001"
11242" moveq #9,d5"
11243" cmpl a5@,sp"
11244" bcc L1001"
11245" TRAP2(24)"
11246" RETURN(L1,1,1)"
11247"L1002:"
11248"L1001:"
11249" JMP_PROC(1,10)"
11250" RETURN(L1,1,1)"
11251"L2:"
11252" movl d1,sp@-"
11253" moveq #48,d3"
11254" moveq #96,d2"
11255" movl #144,d1"
11256" lea L3,a0"
11257" JMP_PROC(2,14)"
11258" RETURN(L1,2,1)"
11259"L3:"
11260" movl d1,sp@-"
11261" moveq #72,d2"
11262" moveq #24,d1"
11263" lea L4,a0"
11264" JMP_PROC(3,10)"
11265" RETURN(L1,3,1)"
11266"L4:"
11267" movl d1,sp@-"
11268" movl #1600000,d1"
11269" lea L5,a0"
11270" JMP_PROC(7,10)"
11271" RETURN(L1,4,1)"
11272"L5:"
11273" dbra d5,L1003"
11274" moveq #9,d5"
11275" cmpl a5@,sp"
11276" bcc L1003"
11277" TRAP2(24)"
11278" RETURN(L1,4,1)"
11279"L1004:"
11280"L1003:"
11281"L6:"
11282" addl sp@(8),d1"
11283" addl sp@(4),d1"
11284" addl sp@+,d1"
11285" addql #8,sp"
11286" rts"
11287"L0:"
11288"|------------------------------------------------------"
11289"| #[primitive fib] ="
11290"L1:"
11291" bmi L1000"
11292" TRAP1(9,1)"
11293" LBL_PTR(L1)"
11294"L1000:"
11295" moveq #16,d0"
11296" cmpl d1,d0"
11297" ble L3"
11298" bra L4"
11299" RETURN(L1,2,1)"
11300"L2:"
11301" movl d1,sp@-"
11302" movl sp@(4),d1"
11303" moveq #-16,d0"
11304" addl d0,d1"
11305" lea L5,a0"
11306" moveq #16,d0"
11307" cmpl d1,d0"
11308" bgt L4"
11309"L3:"
11310" movl a0,sp@-"
11311" movl d1,sp@-"
11312" subql #8,d1"
11313" lea L2,a0"
11314" dbra d5,L1001"
11315" moveq #9,d5"
11316" cmpl a5@,sp"
11317" bcc L1001"
11318" TRAP2(24)"
11319" RETURN(L1,2,1)"
11320"L1002:"
11321"L1001:"
11322" moveq #16,d0"
11323" cmpl d1,d0"
11324" ble L3"
11325"L4:"
11326" jmp a0@"
11327" RETURN(L1,3,1)"
11328"L5:"
11329" addl sp@+,d1"
11330" dbra d5,L1003"
11331" moveq #9,d5"
11332" cmpl a5@,sp"
11333" bcc L1003"
11334" TRAP2(24)"
11335" RETURN(L1,2,1)"
11336"L1004:"
11337"L1003:"
11338" addql #4,sp"
11339" rts"
11340"L0:"
11341"|------------------------------------------------------"
11342"| #[primitive tak] ="
11343"L1:"
11344" cmpw #4,d0"
11345" beq L1000"
11346" TRAP1(9,3)"
11347" LBL_PTR(L1)"
11348"L1000:"
11349" cmpl d1,d2"
11350" bge L4"
11351" bra L3"
11352" RETURN(L1,6,1)"
11353"L2:"
11354" movl d1,d3"
11355" movl sp@(20),a0"
11356" movl sp@+,d2"
11357" movl sp@+,d1"
11358" dbra d5,L1001"
11359" moveq #9,d5"
11360" cmpl a5@,sp"
11361" bcc L1001"
11362" movl a0,sp@(12)"
11363" TRAP2(24)"
11364" RETURN(L1,4,1)"
11365"L1002:"
11366" movl sp@(12),a0"
11367"L1001:"
11368" cmpl d1,d2"
11369" lea sp@(16),sp"
11370" bge L4"
11371"L3:"
11372" movl a0,sp@-"
11373" movl d1,sp@-"
11374" movl d2,sp@-"
11375" movl d3,sp@-"
11376" subql #8,d1"
11377" lea L5,a0"
11378" dbra d5,L1003"
11379" moveq #9,d5"
11380" cmpl a5@,sp"
11381" bcc L1003"
11382" TRAP2(24)"
11383" RETURN(L1,4,1)"
11384"L1004:"
11385"L1003:"
11386" cmpl d1,d2"
11387" blt L3"
11388"L4:"
11389" movl d3,d1"
11390" jmp a0@"
11391" RETURN(L1,4,1)"
11392"L5:"
11393" movl d1,sp@-"
11394" movl sp@(12),d3"
11395" movl sp@(4),d2"
11396" movl sp@(8),d1"
11397" subql #8,d1"
11398" lea L6,a0"
11399" cmpl d1,d2"
11400" bge L4"
11401" bra L3"
11402" RETURN(L1,5,1)"
11403"L6:"
11404" movl d1,sp@-"
11405" movl sp@(12),d3"
11406" movl sp@(16),d2"
11407" movl sp@(8),d1"
11408" subql #8,d1"
11409" lea L2,a0"
11410" cmpl d1,d2"
11411" bge L4"
11412" bra L3"
11413"L0:"
11414"|------------------------------------------------------"
11415"| #[primitive ack] ="
11416"L1:"
11417" beq L1000"
11418" TRAP1(9,2)"
11419" LBL_PTR(L1)"
11420"L1000:"
11421" movl d1,d0"
11422" bne L3"
11423" bra L5"
11424" RETURN(L1,2,1)"
11425"L2:"
11426" movl d1,d2"
11427" movl sp@+,d1"
11428" subql #8,d1"
11429" movl sp@+,a0"
11430" dbra d5,L1001"
11431" moveq #9,d5"
11432" cmpl a5@,sp"
11433" bcc L1001"
11434" movl a0,sp@-"
11435" TRAP2(24)"
11436" RETURN(L1,1,1)"
11437"L1002:"
11438" movl sp@+,a0"
11439"L1001:"
11440" movl d1,d0"
11441" beq L5"
11442"L3:"
11443" movl d2,d0"
11444" bne L6"
11445"L4:"
11446" subql #8,d1"
11447" moveq #8,d2"
11448" dbra d5,L1003"
11449" moveq #9,d5"
11450" cmpl a5@,sp"
11451" bcc L1003"
11452" movl a0,sp@-"
11453" TRAP2(24)"
11454" RETURN(L1,1,1)"
11455"L1004:"
11456" movl sp@+,a0"
11457"L1003:"
11458" movl d1,d0"
11459" bne L3"
11460"L5:"
11461" movl d2,d1"
11462" addql #8,d1"
11463" jmp a0@"
11464"L6:"
11465" movl a0,sp@-"
11466" movl d1,sp@-"
11467" movl d2,d1"
11468" subql #8,d1"
11469" movl d1,d2"
11470" movl sp@,d1"
11471" lea L2,a0"
11472" dbra d5,L1005"
11473" moveq #9,d5"
11474" cmpl a5@,sp"
11475" bcc L1005"
11476" TRAP2(24)"
11477" RETURN(L1,2,1)"
11478"L1006:"
11479"L1005:"
11480" movl d1,d0"
11481" bne L3"
11482" bra L5"
11483"L0:"
11484"|------------------------------------------------------"
11485"| #[primitive create-x] ="
11486"L1:"
11487" bmi L1000"
11488" TRAP1(9,1)"
11489" LBL_PTR(L1)"
11490"L1000:"
11491" movl a0,sp@-"
11492" movl d1,sp@-"
11493" lea L2,a0"
11494" dbra d5,L1001"
11495" moveq #9,d5"
11496" cmpl a5@,sp"
11497" bcc L1001"
11498" TRAP2(24)"
11499" RETURN(L1,2,1)"
11500"L1002:"
11501"L1001:"
11502" moveq #-1,d0"
11503" JMP_PRIM(make-vector,0)"
11504" RETURN(L1,2,1)"
11505"L2:"
11506" movl d1,d2"
11507" movl sp@+,d1"
11508" moveq #0,d3"
11509" movl sp@+,a0"
11510" dbra d5,L1003"
11511" moveq #9,d5"
11512" cmpl a5@,sp"
11513" bcc L1003"
11514" movl a0,sp@-"
11515" TRAP2(24)"
11516" RETURN(L1,1,1)"
11517"L1004:"
11518" movl sp@+,a0"
11519"L1003:"
11520" cmpl d1,d3"
11521" bge L4"
11522"L3:"
11523" movl d3,d0"
11524" asrl #1,d0"
11525" movl d2,a1"
11526" movl d3,a1@(1,d0:l)"
11527" addql #8,d3"
11528" dbra d5,L1005"
11529" moveq #9,d5"
11530" cmpl a5@,sp"
11531" bcc L1005"
11532" movl a0,sp@-"
11533" TRAP2(24)"
11534" RETURN(L1,1,1)"
11535"L1006:"
11536" movl sp@+,a0"
11537"L1005:"
11538" cmpl d1,d3"
11539" blt L3"
11540"L4:"
11541" movl d2,d1"
11542" jmp a0@"
11543"L0:"
11544"|------------------------------------------------------"
11545"| #[primitive create-y] ="
11546"L1:"
11547" bmi L1000"
11548" TRAP1(9,1)"
11549" LBL_PTR(L1)"
11550"L1000:"
11551" movl d1,a1"
11552" movl a1@(-3),d2"
11553" lsrl #7,d2"
11554" movl a0,sp@-"
11555" movl d1,sp@-"
11556" movl d2,sp@-"
11557" movl d2,d1"
11558" lea L2,a0"
11559" dbra d5,L1001"
11560" moveq #9,d5"
11561" cmpl a5@,sp"
11562" bcc L1001"
11563" TRAP2(24)"
11564" RETURN(L1,3,1)"
11565"L1002:"
11566"L1001:"
11567" moveq #-1,d0"
11568" JMP_PRIM(make-vector,0)"
11569" RETURN(L1,3,1)"
11570"L2:"
11571" movl sp@+,d2"
11572" subql #8,d2"
11573" movl d2,d3"
11574" movl d1,d2"
11575" movl sp@+,d1"
11576" movl sp@+,a0"
11577" dbra d5,L1003"
11578" moveq #9,d5"
11579" cmpl a5@,sp"
11580" bcc L1003"
11581" movl a0,sp@-"
11582" TRAP2(24)"
11583" RETURN(L1,1,1)"
11584"L1004:"
11585" movl sp@+,a0"
11586"L1003:"
11587" movl d3,d0"
11588" blt L4"
11589"L3:"
11590" movl d3,d0"
11591" asrl #1,d0"
11592" movl d1,a1"
11593" movl a1@(1,d0:l),d4"
11594" movl d3,d0"
11595" asrl #1,d0"
11596" movl d2,a1"
11597" movl d4,a1@(1,d0:l)"
11598" subql #8,d3"
11599" dbra d5,L1005"
11600" moveq #9,d5"
11601" cmpl a5@,sp"
11602" bcc L1005"
11603" movl a0,sp@-"
11604" TRAP2(24)"
11605" RETURN(L1,1,1)"
11606"L1006:"
11607" movl sp@+,a0"
11608"L1005:"
11609" movl d3,d0"
11610" bge L3"
11611"L4:"
11612" movl d2,d1"
11613" jmp a0@"
11614"L0:"
11615"|------------------------------------------------------"
11616"| #[primitive my-try] ="
11617"L1:"
11618" bmi L1000"
11619" TRAP1(9,1)"
11620" LBL_PTR(L1)"
11621"L1000:"
11622" movl a0,sp@-"
11623" lea L2,a0"
11624" dbra d5,L1001"
11625" moveq #9,d5"
11626" cmpl a5@,sp"
11627" bcc L1001"
11628" TRAP2(24)"
11629" RETURN(L1,1,1)"
11630"L1002:"
11631"L1001:"
11632" JMP_PROC(4,10)"
11633" RETURN(L1,1,1)"
11634"L2:"
11635" lea L3,a0"
11636" JMP_PROC(5,10)"
11637" RETURN(L1,1,1)"
11638"L3:"
11639" movl d1,a1"
11640" movl a1@(-3),d1"
11641" lsrl #7,d1"
11642" dbra d5,L1003"
11643" moveq #9,d5"
11644" cmpl a5@,sp"
11645" bcc L1003"
11646" TRAP2(24)"
11647" RETURN(L1,1,1)"
11648"L1004:"
11649"L1003:"
11650" rts"
11651"L0:"
11652"|------------------------------------------------------"
11653"| #[primitive go] ="
11654"L1:"
11655" bmi L1000"
11656" TRAP1(9,1)"
11657" LBL_PTR(L1)"
11658"L1000:"
11659" moveq #0,d3"
11660" movl #800,d2"
11661" dbra d5,L1001"
11662" moveq #9,d5"
11663" cmpl a5@,sp"
11664" bcc L1001"
11665" movl a0,sp@-"
11666" TRAP2(24)"
11667" RETURN(L1,1,1)"
11668"L1002:"
11669" movl sp@+,a0"
11670"L1001:"
11671" movl d2,d0"
11672" ble L4"
11673" bra L3"
11674" RETURN(L1,3,1)"
11675"L2:"
11676" movl d1,d3"
11677" movl sp@+,d1"
11678" subql #8,d1"
11679" movl d1,d2"
11680" movl sp@+,d1"
11681" movl sp@+,a0"
11682" dbra d5,L1003"
11683" moveq #9,d5"
11684" cmpl a5@,sp"
11685" bcc L1003"
11686" movl a0,sp@-"
11687" TRAP2(24)"
11688" RETURN(L1,1,1)"
11689"L1004:"
11690" movl sp@+,a0"
11691"L1003:"
11692" movl d2,d0"
11693" ble L4"
11694"L3:"
11695" movl a0,sp@-"
11696" movl d1,sp@-"
11697" movl d2,sp@-"
11698" lea L2,a0"
11699" dbra d5,L1005"
11700" moveq #9,d5"
11701" cmpl a5@,sp"
11702" bcc L1005"
11703" TRAP2(24)"
11704" RETURN(L1,3,1)"
11705"L1006:"
11706"L1005:"
11707" JMP_PROC(6,10)"
11708"L4:"
11709" movl d3,d1"
11710" jmp a0@"
11711"L0:"
11712""))
11713
11714(define (main . args)
11715  (run-benchmark
11716    "compiler"
11717    compiler-iters
11718    (lambda (result)
11719      (equal? result output-expected))
11720    (lambda (expr target opt) (lambda () (ce expr target opt) (asm-output-get)))
11721    input-source-code
11722    'm68000
11723    'asm))
11724
11725(main)
Trap